475 files changed, 69153 insertions, 35322 deletions

diff --git a/module/AccountManager.py b/module/AccountManager.py
new file mode 100644
index 000000000..45b4eef95
--- /dev/null
+++ b/module/AccountManager.py
@@ -0,0 +1,140 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+###############################################################################
+#   Copyright(c) 2008-2012 pyLoad Team
+#   http://www.pyload.org
+#
+#   This file is part of pyLoad.
+#   pyLoad is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU Affero General Public License as
+#   published by the Free Software Foundation, either version 3 of the
+#   License, or (at your option) any later version.
+#
+#   Subjected to the terms and conditions in LICENSE
+#
+#   @author: RaNaN, mkaay
+###############################################################################
+
+from threading import Lock
+from random import choice
+
+from module.common.json_layer import json
+from module.utils import lock
+
+class AccountManager:
+    """manages all accounts"""
+
+    def __init__(self, core):
+        """Constructor"""
+
+        self.core = core
+        self.lock = Lock()
+
+        self.loadAccounts()
+
+    def loadAccounts(self):
+        """loads all accounts available"""
+
+        self.accounts = {}
+
+        for plugin, loginname, activated, password, options in self.core.db.loadAccounts():
+            # put into options as used in other context
+            options = json.loads(options) if options else {}
+            options["activated"] = activated
+
+            self.createAccount(plugin, loginname, password, options)
+
+        return
+
+    def iterAccounts(self):
+        """ yields login, account  for all accounts"""
+        for name, data in self.accounts.iteritems():
+            for login, account in data.iteritems():
+                yield login, account
+
+    def saveAccounts(self):
+        """save all account information"""
+
+        data = []
+        for name, plugin in self.accounts.iteritems():
+            data.extend([(name, acc.loginname, acc.activated, acc.password, json.dumps(acc.options)) for acc in
+                                                                                                     plugin.itervalues()])
+        self.core.db.saveAccounts(data)
+
+    def createAccount(self, plugin, loginname, password, options):
+        klass = self.core.pluginManager.loadClass("accounts", plugin)
+        if not klass:
+            self.core.log.warning(_("Unknown account plugin %s") % plugin)
+            return
+
+        if plugin not in self.accounts:
+            self.accounts[plugin] = {}
+
+        self.core.log.debug("Create account %s:%s" % (plugin, loginname))
+
+        self.accounts[plugin][loginname] = klass(self, loginname, password, options)
+
+
+    def getAccount(self, plugin, user):
+        return self.accounts[plugin].get(user, None)
+
+    @lock
+    def updateAccount(self, plugin, user, password=None, options={}):
+        """add or update account"""
+        if plugin in self.accounts and user in self.accounts[plugin]:
+            acc = self.accounts[plugin][user]
+            updated = acc.update(password, options)
+
+            self.saveAccounts()
+            if updated: acc.scheduleRefresh(force=True)
+        else:
+            self.createAccount(plugin, user, password, options)
+            self.saveAccounts()
+
+        self.sendChange(plugin, user)
+
+    @lock
+    def removeAccount(self, plugin, user):
+        """remove account"""
+        if plugin in self.accounts and user in self.accounts[plugin]:
+            del self.accounts[plugin][user]
+            self.core.db.removeAccount(plugin, user)
+            self.core.eventManager.dispatchEvent("accountDeleted", plugin, user)
+        else:
+            self.core.log.debug("Remove non existing account %s %s" % (plugin, user))
+
+
+    @lock
+    def getAccountForPlugin(self, plugin):
+        if plugin in self.accounts:
+            accs = [x for x in self.accounts[plugin].values() if x.isUsable()]
+            if accs: return choice(accs)
+
+        return None
+
+    @lock
+    def getAllAccounts(self, refresh=False):
+        """ Return account info, refresh afterwards if needed
+
+        :param refresh:
+        :return:
+        """
+        if refresh:
+            self.core.scheduler.addJob(0, self.core.accountManager.getAllAccounts)
+
+        # load unavailable account info
+        for p_dict in self.accounts.itervalues():
+            for acc in p_dict.itervalues():
+                acc.getAccountInfo()
+
+        return self.accounts
+
+    def refreshAllAccounts(self):
+        """ Force a refresh of every account """
+        for p in self.accounts.itervalues():
+            for acc in p.itervalues():
+                acc.getAccountInfo(True)
+
+    def sendChange(self, plugin, name):
+        self.core.eventManager.dispatchEvent("accountUpdated", plugin, name)
\ No newline at end of file
diff --git a/module/AddonManager.py b/module/AddonManager.py
new file mode 100644
index 000000000..cc2181767
--- /dev/null
+++ b/module/AddonManager.py
@@ -0,0 +1,248 @@
+# -*- coding: utf-8 -*-
+
+###############################################################################
+#   Copyright(c) 2008-2013 pyLoad Team
+#   http://www.pyload.org
+#
+#   This file is part of pyLoad.
+#   pyLoad is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU Affero General Public License as
+#   published by the Free Software Foundation, either version 3 of the
+#   License, or (at your option) any later version.
+#
+#   Subjected to the terms and conditions in LICENSE
+#
+#   @author: RaNaN
+###############################################################################
+
+import __builtin__
+
+from thread import start_new_thread
+from threading import RLock
+
+from types import MethodType
+
+from module.threads.AddonThread import AddonThread
+from module.PluginManager import literal_eval
+from utils import lock, to_string
+
+class AddonManager:
+    """ Manages addons, loading, unloading.  """
+
+    def __init__(self, core):
+        self.core = core
+        self.config = self.core.config
+
+        __builtin__.addonManager = self #needed to let addons register themselves
+
+        self.log = self.core.log
+        self.plugins = {}
+        self.methods = {} # dict of names and list of methods usable by rpc
+        self.events = {} # Contains event that will be registered
+
+        self.lock = RLock()
+        self.createIndex()
+
+        # manage addons on config change
+        self.addEvent("config:changed", self.manageAddons)
+
+    @lock
+    def callInHooks(self, event, eventName, *args):
+        """  Calls a method in all addons and catch / log errors"""
+        for plugin in self.plugins.itervalues():
+            self.call(plugin, event, *args)
+        self.dispatchEvent(eventName, *args)
+
+    def call(self, addon, f, *args):
+        try:
+            func = getattr(addon, f)
+            return func(*args)
+        except Exception, e:
+            addon.logError(_("Error when executing %s" % f), e)
+            self.core.print_exc()
+
+    def addRPC(self, plugin, func, doc):
+        doc = doc.strip() if doc else ""
+
+        if plugin in self.methods:
+            self.methods[plugin][func] = doc
+        else:
+            self.methods[plugin] = {func: doc}
+
+    def callRPC(self, plugin, func, args):
+        if not args: args = []
+        else:
+            args = literal_eval(args)
+
+        plugin = self.plugins[plugin]
+        f = getattr(plugin, func)
+        return f(*args)
+
+    @lock
+    def createIndex(self):
+        active = []
+        deactive = []
+
+        for pluginname in self.core.pluginManager.getPlugins("addons"):
+            try:
+                # check first for builtin plugin
+                attrs = self.core.pluginManager.loadAttributes("addons", pluginname)
+                internal = attrs.get("internal", False)
+
+                if internal or self.core.config.get(pluginname, "activated"):
+                    pluginClass = self.core.pluginManager.loadClass("addons", pluginname)
+
+                    if not pluginClass: continue
+
+                    plugin = pluginClass(self.core, self)
+                    self.plugins[pluginClass.__name__] = plugin
+
+                    # hide internals from printing
+                    if not internal and plugin.isActivated():
+                        active.append(pluginClass.__name__)
+                    else:
+                        self.log.debug("Loaded internal plugin: %s" % pluginClass.__name__)
+                else:
+                    deactive.append(pluginname)
+
+
+            except:
+                self.log.warning(_("Failed activating %(name)s") % {"name": pluginname})
+                self.core.print_exc()
+
+        self.log.info(_("Activated addons: %s") % ", ".join(sorted(active)))
+        self.log.info(_("Deactivate addons: %s") % ", ".join(sorted(deactive)))
+
+    def manageAddons(self, plugin, name, value):
+        # check if section was a plugin
+        if plugin not in self.core.pluginManager.getPlugins("addons"):
+            return
+
+        if name == "activated" and value:
+            self.activateAddon(plugin)
+        elif name == "activated" and not value:
+            self.deactivateAddon(plugin)
+
+    @lock
+    def activateAddon(self, plugin):
+        #check if already loaded
+        if plugin in self.plugins:
+            return
+
+        pluginClass = self.core.pluginManager.loadClass("addons", plugin)
+
+        if not pluginClass: return
+
+        self.log.debug("Plugin loaded: %s" % plugin)
+
+        plugin = pluginClass(self.core, self)
+        self.plugins[pluginClass.__name__] = plugin
+
+        # active the addon in new thread
+        start_new_thread(plugin.activate, tuple())
+        self.registerEvents() # TODO: BUG: events will be destroyed and not re-registered
+
+    @lock
+    def deactivateAddon(self, plugin):
+        if plugin not in self.plugins:
+            return
+        else:
+            addon = self.plugins[plugin]
+
+        if addon.__internal__: return
+
+        self.call(addon, "deactivate")
+        self.log.debug("Plugin deactivated: %s" % plugin)
+
+        #remove periodic call
+        self.log.debug("Removed callback %s" % self.core.scheduler.removeJob(addon.cb))
+        del self.plugins[addon.__name__]
+
+        #remove event listener
+        for f in dir(addon):
+            if f.startswith("__") or type(getattr(addon, f)) != MethodType:
+                continue
+            self.core.eventManager.removeFromEvents(getattr(addon, f))
+
+    def activateAddons(self):
+        self.log.info(_("Activating Plugins..."))
+        for plugin in self.plugins.itervalues():
+            if plugin.isActivated():
+                self.call(plugin, "activate")
+
+        self.registerEvents()
+
+    def deactivateAddons(self):
+        """  Called when core is shutting down """
+        self.log.info(_("Deactivating Plugins..."))
+        for plugin in self.plugins.itervalues():
+            self.call(plugin, "deactivate")
+
+    def downloadPreparing(self, pyfile):
+        self.callInHooks("downloadPreparing", "download:preparing", pyfile)
+
+    def downloadFinished(self, pyfile):
+        self.callInHooks("downloadFinished", "download:finished", pyfile)
+
+    def downloadFailed(self, pyfile):
+        self.callInHooks("downloadFailed", "download:failed", pyfile)
+
+    def packageFinished(self, package):
+        self.callInHooks("packageFinished", "package:finished", package)
+
+    def beforeReconnecting(self, ip):
+        self.callInHooks("beforeReconnecting", "reconnecting:before", ip)
+
+    def afterReconnecting(self, ip):
+        self.callInHooks("afterReconnecting", "reconnecting:after", ip)
+
+    @lock
+    def startThread(self, function, *args, **kwargs):
+        AddonThread(self.core.threadManager, function, args, kwargs)
+
+    def activePlugins(self):
+        """ returns all active plugins """
+        return [x for x in self.plugins.itervalues() if x.isActivated()]
+
+    def getAllInfo(self):
+        """returns info stored by addon plugins"""
+        info = {}
+        for name, plugin in self.plugins.iteritems():
+            if plugin.info:
+                #copy and convert so str
+                info[name] = dict(
+                    [(x, to_string(y)) for x, y in plugin.info.iteritems()])
+        return info
+
+    def getInfo(self, plugin):
+        info = {}
+        if plugin in self.plugins and self.plugins[plugin].info:
+            info = dict([(x, to_string(y))
+            for x, y in self.plugins[plugin].info.iteritems()])
+
+        return info
+
+    def addEventListener(self, plugin, func, event):
+        """ add the event to the list """
+        if plugin not in self.events:
+            self.events[plugin] = []
+        self.events[plugin].append((func, event))
+
+    def registerEvents(self):
+        """ actually register all saved events """
+        for name, plugin in self.plugins.iteritems():
+            if name in self.events:
+                for func, event in self.events[name]:
+                    self.addEvent(event, getattr(plugin, func))
+                # clean up
+                del self.events[name]
+
+    def addConfigHandler(self, plugin, func):
+        pass #TODO
+
+    def addEvent(self, *args):
+        self.core.eventManager.addEvent(*args)
+
+    def dispatchEvent(self, *args):
+        self.core.eventManager.dispatchEvent(*args)
+    
diff --git a/module/Api.py b/module/Api.py
index f0bf5e264..bfeeff10c 100644
--- a/module/Api.py
+++ b/module/Api.py
@@ -1,908 +1,136 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-"""
-    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.
+###############################################################################
+#   Copyright(c) 2008-2013 pyLoad Team
+#   http://www.pyload.org
+#
+#   This file is part of pyLoad.
+#   pyLoad is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU Affero General Public License as
+#   published by the Free Software Foundation, either version 3 of the
+#   License, or (at your option) any later version.
+#
+#   Subjected to the terms and conditions in LICENSE
+#
+#   @author: RaNaN
+###############################################################################
 
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, see <http://www.gnu.org/licenses/>.
-
-    @author: RaNaN
-"""
-
-from base64 import standard_b64encode
-from os.path import join
-from time import time
 import re
+from types import MethodType
 
-from PyFile import PyFile
-from utils import freeSpace, compare_time
-from common.packagetools import parseNames
-from network.RequestFactory import getURL
-from remote import activated
-
-if activated:
-    try:
-        from remote.thriftbackend.thriftgen.pyload.ttypes import *
-        from remote.thriftbackend.thriftgen.pyload.Pyload import Iface
-        BaseObject = TBase
-    except ImportError:
-        print "Thrift not imported"
-        from remote.socketbackend.ttypes import *
-else:
-    from remote.socketbackend.ttypes import *
+from remote.apitypes import *
 
 # contains function names mapped to their permissions
 # unlisted functions are for admins only
-permMap = {}
+perm_map = {}
 
 # decorator only called on init, never initialized, so has no effect on runtime
-def permission(bits):
+def RequirePerm(bits):
     class _Dec(object):
         def __new__(cls, func, *args, **kwargs):
-            permMap[func.__name__] = bits
+            perm_map[func.__name__] = bits
             return func
-        
-    return _Dec
 
+    return _Dec
 
 urlmatcher = re.compile(r"((https?|ftps?|xdcc|sftp):((//)|(\\\\))+[\w\d:#@%/;$()~_?\+\-=\\\.&]*)", re.IGNORECASE)
 
-class PERMS:
-    ALL = 0  # requires no permission, but login
-    ADD = 1  # can add packages
-    DELETE = 2 # can delete packages
-    STATUS = 4   # see and change server status
-    LIST = 16 # see queue and collector
-    MODIFY = 32 # moddify some attribute of downloads
-    DOWNLOAD = 64  # can download from webinterface
-    SETTINGS = 128 # can access settings
-    ACCOUNTS = 256 # can access accounts
-    LOGS = 512 # can see server logs
+stateMap = {
+    DownloadState.All: frozenset(getattr(DownloadStatus, x) for x in dir(DownloadStatus) if not x.startswith("_")),
+    DownloadState.Finished: frozenset((DownloadStatus.Finished, DownloadStatus.Skipped)),
+    DownloadState.Unfinished: None, # set below
+    DownloadState.Failed: frozenset((DownloadStatus.Failed, DownloadStatus.TempOffline, DownloadStatus.Aborted)),
+    DownloadState.Unmanaged: None, #TODO
+}
 
-class ROLE:
-    ADMIN = 0  #admin has all permissions implicit
-    USER = 1
+stateMap[DownloadState.Unfinished] = frozenset(stateMap[DownloadState.All].difference(stateMap[DownloadState.Finished]))
 
-def has_permission(userperms, perms):
-    # bytewise or perms before if needed
-    return perms == (userperms & perms)
+def state_string(state):
+    return ",".join(str(x) for x in stateMap[state])
 
+from datatypes.User import User
 
 class Api(Iface):
     """
     **pyLoads API**
 
-    This is accessible either internal via core.api or via thrift backend.
+    This is accessible either internal via core.api, websocket backend or json api.
 
     see Thrift specification file remote/thriftbackend/pyload.thrift\
-    for information about data structures and what methods are usuable with rpc.
+    for information about data structures and what methods are usable with rpc.
 
     Most methods requires specific permissions, please look at the source code if you need to know.\
-    These can be configured via webinterface.
+    These can be configured via web interface.
     Admin user have all permissions, and are the only ones who can access the methods with no specific permission.
     """
 
     EXTERNAL = Iface  # let the json api know which methods are external
+    EXTEND = False  # only extendable when set too true
 
     def __init__(self, core):
         self.core = core
+        self.user_apis = {}
 
-    def _convertPyFile(self, p):
-        f = FileData(p["id"], p["url"], p["name"], p["plugin"], p["size"],
-                     p["format_size"], p["status"], p["statusmsg"],
-                     p["package"], p["error"], p["order"])
-        return f
-
-    def _convertConfigFormat(self, c):
-        sections = {}
-        for sectionName, sub in c.iteritems():
-            section = ConfigSection(sectionName, sub["desc"])
-            items = []
-            for key, data in sub.iteritems():
-                if key in ("desc", "outline"):
-                    continue
-                item = ConfigItem()
-                item.name = key
-                item.description = data["desc"]
-                item.value = str(data["value"]) if not isinstance(data["value"], basestring) else data["value"]
-                item.type = data["type"]
-                items.append(item)
-            section.items = items
-            sections[sectionName] = section
-            if "outline" in sub:
-                section.outline = sub["outline"]
-        return sections
-
-    @permission(PERMS.SETTINGS)
-    def getConfigValue(self, category, option, section="core"):
-        """Retrieve config value.
-
-        :param category: name of category, or plugin
-        :param option: config option
-        :param section: 'plugin' or 'core'
-        :return: config value as string
-        """
-        if section == "core":
-            value = self.core.config[category][option]
-        else:
-            value = self.core.config.getPlugin(category, option)
-
-        return str(value) if not isinstance(value, basestring) else value
-
-    @permission(PERMS.SETTINGS)
-    def setConfigValue(self, category, option, value, section="core"):
-        """Set new config value.
+    @property
+    def user(self):
+        return None #TODO return default user?
 
-        :param category:
-        :param option:
-        :param value: new config value
-        :param section: 'plugin' or 'core
-        """
-        self.core.hookManager.dispatchEvent("configChanged", category, option, value, section)
+    @property
+    def primaryUID(self):
+        return self.user.primary if self.user else None
 
-        if section == "core":
-            self.core.config[category][option] = value
+    @classmethod
+    def initComponents(cls):
+        # Allow extending the api
+        # This prevents unintentionally registering of the components,
+        # but will only work once when they are imported
+        cls.EXTEND = True
+        # Import all Api modules, they register themselves.
+        import module.api
+        # they will vanish from the namespace afterwards
 
-            if option in ("limit_speed", "max_speed"): #not so nice to update the limit
-                self.core.requestFactory.updateBucket()
 
-        elif section == "plugin":
-            self.core.config.setPlugin(category, option, value)
+    @classmethod
+    def extend(cls, api):
+        """Takes all params from api and extends cls with it.
+            api class can be removed afterwards
 
-    @permission(PERMS.SETTINGS)
-    def getConfig(self):
-        """Retrieves complete config of core.
-        
-        :return: list of `ConfigSection`
+        :param api: Class with methods to extend
         """
-        return self._convertConfigFormat(self.core.config.config)
-
-    def getConfigDict(self):
-        """Retrieves complete config in dict format, not for RPC.
+        if cls.EXTEND:
+            for name, func in api.__dict__.iteritems():
+                if name.startswith("_"): continue
+                setattr(cls, name, MethodType(func, None, cls))
 
-        :return: dict
-        """
-        return self.core.config.config
+        return cls.EXTEND
 
-    @permission(PERMS.SETTINGS)
-    def getPluginConfig(self):
-        """Retrieves complete config for all plugins.
+    def withUserContext(self, uid):
+        """ Returns a proxy version of the api, to call method in user context
 
-        :return: list of `ConfigSection`
+        :param uid: user or userData instance or uid
+        :return: :class:`UserApi`
         """
-        return self._convertConfigFormat(self.core.config.plugin)
-
-    def getPluginConfigDict(self):
-        """Plugin config as dict, not for RPC.
-
-        :return: dict
-        """
-        return self.core.config.plugin
-
-
-    @permission(PERMS.STATUS)
-    def pauseServer(self):
-        """Pause server: Tt wont start any new downloads, but nothing gets aborted."""
-        self.core.threadManager.pause = True
-
-    @permission(PERMS.STATUS)
-    def unpauseServer(self):
-        """Unpause server: New Downloads will be started."""
-        self.core.threadManager.pause = False
-
-    @permission(PERMS.STATUS)
-    def togglePause(self):
-        """Toggle pause state.
-
-        :return: new pause state
-        """
-        self.core.threadManager.pause ^= True
-        return self.core.threadManager.pause
-
-    @permission(PERMS.STATUS)
-    def toggleReconnect(self):
-        """Toggle reconnect activation.
-
-        :return: new reconnect state
-        """
-        self.core.config["reconnect"]["activated"] ^= True
-        return self.core.config["reconnect"]["activated"]
-
-    @permission(PERMS.LIST)
-    def statusServer(self):
-        """Some general information about the current status of pyLoad.
-        
-        :return: `ServerStatus`
-        """
-        serverStatus = ServerStatus(self.core.threadManager.pause, len(self.core.threadManager.processingIds()),
-                                    self.core.files.getQueueCount(), self.core.files.getFileCount(), 0,
-                                    not self.core.threadManager.pause and self.isTimeDownload(),
-                                    self.core.config['reconnect']['activated'] and self.isTimeReconnect())
-
-        for pyfile in [x.active for x in self.core.threadManager.threads if x.active and isinstance(x.active, PyFile)]:
-            serverStatus.speed += pyfile.getSpeed() #bytes/s
-
-        return serverStatus
+        if isinstance(uid, User):
+            uid = uid.uid
 
-    @permission(PERMS.STATUS)
-    def freeSpace(self):
-        """Available free space at download directory in bytes"""
-        return freeSpace(self.core.config["general"]["download_folder"])
-
-    @permission(PERMS.ALL)
-    def getServerVersion(self):
-        """pyLoad Core version """
-        return self.core.version
-
-    def kill(self):
-        """Clean way to quit pyLoad"""
-        self.core.do_kill = True
-
-    def restart(self):
-        """Restart pyload core"""
-        self.core.do_restart = True
-
-    @permission(PERMS.LOGS)
-    def getLog(self, offset=0):
-        """Returns most recent log entries.
-
-        :param offset: line offset
-        :return: List of log entries
-        """
-        filename = join(self.core.config['log']['log_folder'], 'log.txt')
-        try:
-            fh = open(filename, "r")
-            lines = fh.readlines()
-            fh.close()
-            if offset >= len(lines):
-                return []
-            return lines[offset:]
-        except:
-            return ['No log available']
-
-    @permission(PERMS.STATUS)
-    def isTimeDownload(self):
-        """Checks if pyload will start new downloads according to time in config.
-
-        :return: bool
-        """
-        start = self.core.config['downloadTime']['start'].split(":")
-        end = self.core.config['downloadTime']['end'].split(":")
-        return compare_time(start, end)
-
-    @permission(PERMS.STATUS)
-    def isTimeReconnect(self):
-        """Checks if pyload will try to make a reconnect
-
-        :return: bool
-        """
-        start = self.core.config['reconnect']['startTime'].split(":")
-        end = self.core.config['reconnect']['endTime'].split(":")
-        return compare_time(start, end) and self.core.config["reconnect"]["activated"]
-
-    @permission(PERMS.LIST)
-    def statusDownloads(self):
-        """ Status off all currently running downloads.
-
-        :return: list of `DownloadStatus`
-        """
-        data = []
-        for pyfile in self.core.threadManager.getActiveFiles():
-            if not isinstance(pyfile, PyFile):
-                continue
-
-            data.append(DownloadInfo(
-                pyfile.id, pyfile.name, pyfile.getSpeed(), pyfile.getETA(), pyfile.formatETA(),
-                pyfile.getBytesLeft(), pyfile.getSize(), pyfile.formatSize(), pyfile.getPercent(),
-                pyfile.status, pyfile.getStatusName(), pyfile.formatWait(),
-                pyfile.waitUntil, pyfile.packageid, pyfile.package().name, pyfile.pluginname))
-
-        return data
-
-    @permission(PERMS.ADD)
-    def addPackage(self, name, links, dest=Destination.Queue):
-        """Adds a package, with links to desired destination.
-
-        :param name: name of the new package
-        :param links: list of urls
-        :param dest: `Destination`
-        :return: package id of the new package
-        """
-        if self.core.config['general']['folder_per_package']:
-            folder = name
-        else:
-            folder = ""
-
-        folder = folder.replace("http://", "").replace(":", "").replace("/", "_").replace("\\", "_")
-
-        pid = self.core.files.addPackage(name, folder, dest)
-
-        self.core.files.addLinks(links, pid)
-
-        self.core.log.info(_("Added package %(name)s containing %(count)d links") % {"name": name, "count": len(links)})
-
-        self.core.files.save()
-
-        return pid
-
-    @permission(PERMS.ADD)
-    def parseURLs(self, html=None, url=None):
-        """Parses html content or any arbitaty text for links and returns result of `checkURLs`
-
-        :param html: html source
-        :return:
-        """
-        urls = []
+        if uid not in self.user_apis:
+            user = self.core.db.getUserData(uid=uid)
+            if not user: #TODO: anonymous user?
+                return None
 
-        if html:
-            urls += [x[0] for x in urlmatcher.findall(html)]
+            self.user_apis[uid] = UserApi(self.core, User.fromUserData(self, user))
 
-        if url:
-            page = getURL(url)
-            urls += [x[0] for x in urlmatcher.findall(page)]
+        return self.user_apis[uid]
 
-        # remove duplicates
-        return self.checkURLs(set(urls))
 
+    #############################
+    #  Auth+User Information
+    #############################
 
-    @permission(PERMS.ADD)
-    def checkURLs(self, urls):
-        """ Gets urls and returns pluginname mapped to list of matches urls.
-
-        :param urls:
-        :return: {plugin: urls}
-        """
-        data = self.core.pluginManager.parseUrls(urls)
-        plugins = {}
-
-        for url, plugin in data:
-            if plugin in plugins:
-                plugins[plugin].append(url)
-            else:
-                plugins[plugin] = [url]
-
-        return plugins
-
-    @permission(PERMS.ADD)
-    def checkOnlineStatus(self, urls):
-        """ initiates online status check
-
-        :param urls:
-        :return: initial set of data as `OnlineCheck` instance containing the result id
-        """
-        data = self.core.pluginManager.parseUrls(urls)
-
-        rid = self.core.threadManager.createResultThread(data, False)
-
-        tmp = [(url, (url, OnlineStatus(url, pluginname, "unknown", 3, 0))) for url, pluginname in data]
-        data = parseNames(tmp)
-        result = {}
-
-        for k, v in data.iteritems():
-            for url, status in v:
-                status.packagename = k
-                result[url] = status
-
-        return OnlineCheck(rid, result)
-
-    @permission(PERMS.ADD)
-    def checkOnlineStatusContainer(self, urls, container, data):
-        """ checks online status of urls and a submited container file
-
-        :param urls: list of urls
-        :param container: container file name
-        :param data: file content
-        :return: online check
-        """
-        th = open(join(self.core.config["general"]["download_folder"], "tmp_" + container), "wb")
-        th.write(str(data))
-        th.close()
-
-        return self.checkOnlineStatus(urls + [th.name])
-
-    @permission(PERMS.ADD)
-    def pollResults(self, rid):
-        """ Polls the result available for ResultID
-
-        :param rid: `ResultID`
-        :return: `OnlineCheck`, if rid is -1 then no more data available
-        """
-        result = self.core.threadManager.getInfoResult(rid)
-
-        if "ALL_INFO_FETCHED" in result:
-            del result["ALL_INFO_FETCHED"]
-            return OnlineCheck(-1, result)
-        else:
-            return OnlineCheck(rid, result)
-
-
-    @permission(PERMS.ADD)
-    def generatePackages(self, links):
-        """ Parses links, generates packages names from urls
-
-        :param links: list of urls
-        :return: package names mapped to urls
-        """
-        result = parseNames((x, x) for x in links)
-        return result
-
-    @permission(PERMS.ADD)
-    def generateAndAddPackages(self, links, dest=Destination.Queue):
-        """Generates and add packages
-
-        :param links: list of urls
-        :param dest: `Destination`
-        :return: list of package ids
-        """
-        return [self.addPackage(name, urls, dest) for name, urls
-                in self.generatePackages(links).iteritems()]
-
-    @permission(PERMS.ADD)
-    def checkAndAddPackages(self, links, dest=Destination.Queue):
-        """Checks online status, retrieves names, and will add packages.\
-        Because of this packages are not added immediatly, only for internal use.
-
-        :param links: list of urls
-        :param dest: `Destination`
-        :return: None
-        """
-        data = self.core.pluginManager.parseUrls(links)
-        self.core.threadManager.createResultThread(data, True)
-
-
-    @permission(PERMS.LIST)
-    def getPackageData(self, pid):
-        """Returns complete information about package, and included files.
-
-        :param pid: package id
-        :return: `PackageData` with .links attribute
-        """
-        data = self.core.files.getPackageData(int(pid))
-
-        if not data:
-            raise PackageDoesNotExists(pid)
-
-        pdata = PackageData(data["id"], data["name"], data["folder"], data["site"], data["password"],
-                            data["queue"], data["order"],
-                            links=[self._convertPyFile(x) for x in data["links"].itervalues()])
-
-        return pdata
-
-    @permission(PERMS.LIST)
-    def getPackageInfo(self, pid):
-        """Returns information about package, without detailed information about containing files
-
-        :param pid: package id
-        :return: `PackageData` with .fid attribute
-        """
-        data = self.core.files.getPackageData(int(pid))
-        
-        if not data:
-            raise PackageDoesNotExists(pid)
-
-        pdata = PackageData(data["id"], data["name"], data["folder"], data["site"], data["password"],
-                            data["queue"], data["order"],
-                            fids=[int(x) for x in data["links"]])
-
-        return pdata
-
-    @permission(PERMS.LIST)
-    def getFileData(self, fid):
-        """Get complete information about a specific file.
-
-        :param fid: file id
-        :return: `FileData`
-        """
-        info = self.core.files.getFileData(int(fid))
-        if not info:
-            raise FileDoesNotExists(fid)
-
-        fdata = self._convertPyFile(info.values()[0])
-        return fdata
-
-    @permission(PERMS.DELETE)
-    def deleteFiles(self, fids):
-        """Deletes several file entries from pyload.
-        
-        :param fids: list of file ids
-        """
-        for id in fids:
-            self.core.files.deleteLink(int(id))
-
-        self.core.files.save()
-
-    @permission(PERMS.DELETE)
-    def deletePackages(self, pids):
-        """Deletes packages and containing links.
-
-        :param pids: list of package ids
-        """
-        for id in pids:
-            self.core.files.deletePackage(int(id))
-
-        self.core.files.save()
-
-    @permission(PERMS.LIST)
-    def getQueue(self):
-        """Returns info about queue and packages, **not** about files, see `getQueueData` \
-        or `getPackageData` instead.
-
-        :return: list of `PackageInfo`
-        """
-        return [PackageData(pack["id"], pack["name"], pack["folder"], pack["site"],
-                            pack["password"], pack["queue"], pack["order"],
-                            pack["linksdone"], pack["sizedone"], pack["sizetotal"],
-                            pack["linkstotal"])
-                for pack in self.core.files.getInfoData(Destination.Queue).itervalues()]
-
-    @permission(PERMS.LIST)
-    def getQueueData(self):
-        """Return complete data about everything in queue, this is very expensive use it sparely.\
-           See `getQueue` for alternative.
-
-        :return: list of `PackageData`
-        """
-        return [PackageData(pack["id"], pack["name"], pack["folder"], pack["site"],
-                            pack["password"], pack["queue"], pack["order"],
-                            pack["linksdone"], pack["sizedone"], pack["sizetotal"],
-                            links=[self._convertPyFile(x) for x in pack["links"].itervalues()])
-                for pack in self.core.files.getCompleteData(Destination.Queue).itervalues()]
-
-    @permission(PERMS.LIST)
-    def getCollector(self):
-        """same as `getQueue` for collector.
+    # TODO
 
-        :return: list of `PackageInfo`
-        """
-        return [PackageData(pack["id"], pack["name"], pack["folder"], pack["site"],
-                            pack["password"], pack["queue"], pack["order"],
-                            pack["linksdone"], pack["sizedone"], pack["sizetotal"],
-                            pack["linkstotal"])
-                for pack in self.core.files.getInfoData(Destination.Collector).itervalues()]
-
-    @permission(PERMS.LIST)
-    def getCollectorData(self):
-        """same as `getQueueData` for collector.
-
-        :return: list of `PackageInfo`
-        """
-        return [PackageData(pack["id"], pack["name"], pack["folder"], pack["site"],
-                            pack["password"], pack["queue"], pack["order"],
-                            pack["linksdone"], pack["sizedone"], pack["sizetotal"],
-                            links=[self._convertPyFile(x) for x in pack["links"].itervalues()])
-                for pack in self.core.files.getCompleteData(Destination.Collector).itervalues()]
-
-
-    @permission(PERMS.ADD)
-    def addFiles(self, pid, links):
-        """Adds files to specific package.
-        
-        :param pid: package id
-        :param links: list of urls
-        """
-        self.core.files.addLinks(links, int(pid))
-
-        self.core.log.info(_("Added %(count)d links to package #%(package)d ") % {"count": len(links), "package": pid})
-        self.core.files.save()
-
-    @permission(PERMS.MODIFY)
-    def pushToQueue(self, pid):
-        """Moves package from Collector to Queue.
-
-        :param pid: package id
-        """
-        self.core.files.setPackageLocation(pid, Destination.Queue)
-
-    @permission(PERMS.MODIFY)
-    def pullFromQueue(self, pid):
-        """Moves package from Queue to Collector.
-
-        :param pid: package id
-        """
-        self.core.files.setPackageLocation(pid, Destination.Collector)
-
-    @permission(PERMS.MODIFY)
-    def restartPackage(self, pid):
-        """Restarts a package, resets every containing files.
-
-        :param pid: package id
-        """
-        self.core.files.restartPackage(int(pid))
-
-    @permission(PERMS.MODIFY)
-    def restartFile(self, fid):
-        """Resets file status, so it will be downloaded again.
-
-        :param fid:  file id
-        """
-        self.core.files.restartFile(int(fid))
-
-    @permission(PERMS.MODIFY)
-    def recheckPackage(self, pid):
-        """Proofes online status of all files in a package, also a default action when package is added.
-
-        :param pid:
-        :return:
-        """
-        self.core.files.reCheckPackage(int(pid))
-
-    @permission(PERMS.MODIFY)
-    def stopAllDownloads(self):
-        """Aborts all running downloads."""
-
-        pyfiles = self.core.files.cache.values()
-        for pyfile in pyfiles:
-            pyfile.abortDownload()
-
-    @permission(PERMS.MODIFY)
-    def stopDownloads(self, fids):
-        """Aborts specific downloads.
-
-        :param fids: list of file ids
-        :return:
-        """
-        pyfiles = self.core.files.cache.values()
-
-        for pyfile in pyfiles:
-            if pyfile.id in fids:
-                pyfile.abortDownload()
-
-    @permission(PERMS.MODIFY)
-    def setPackageName(self, pid, name):
-        """Renames a package.
-
-        :param pid: package id
-        :param name: new package name
-        """
-        pack = self.core.files.getPackage(pid)
-        pack.name = name
-        pack.sync()
-
-    @permission(PERMS.MODIFY)
-    def movePackage(self, destination, pid):
-        """Set a new package location.
-
-        :param destination: `Destination`
-        :param pid: package id
-        """
-        if destination not in (0, 1): return
-        self.core.files.setPackageLocation(pid, destination)
-
-    @permission(PERMS.MODIFY)
-    def moveFiles(self, fids, pid):
-        """Move multiple files to another package
-
-        :param fids: list of file ids
-        :param pid: destination package
-        :return:
-        """
-        #TODO: implement
-        pass
-
-
-    @permission(PERMS.ADD)
-    def uploadContainer(self, filename, data):
-        """Uploads and adds a container file to pyLoad.
-
-        :param filename: filename, extension is important so it can correctly decrypted
-        :param data: file content
-        """
-        th = open(join(self.core.config["general"]["download_folder"], "tmp_" + filename), "wb")
-        th.write(str(data))
-        th.close()
-
-        self.addPackage(th.name, [th.name], Destination.Queue)
-
-    @permission(PERMS.MODIFY)
-    def orderPackage(self, pid, position):
-        """Gives a package a new position.
-
-        :param pid: package id
-        :param position: 
-        """
-        self.core.files.reorderPackage(pid, position)
-
-    @permission(PERMS.MODIFY)
-    def orderFile(self, fid, position):
-        """Gives a new position to a file within its package.
-
-        :param fid: file id
-        :param position:
-        """
-        self.core.files.reorderFile(fid, position)
-
-    @permission(PERMS.MODIFY)
-    def setPackageData(self, pid, data):
-        """Allows to modify several package attributes.
-
-        :param pid: package id
-        :param data: dict that maps attribute to desired value
-        """
-        p = self.core.files.getPackage(pid)
-        if not p: raise PackageDoesNotExists(pid)
-
-        for key, value in data.iteritems():
-            if key == "id": continue
-            setattr(p, key, value)
-
-        p.sync()
-        self.core.files.save()
-
-    @permission(PERMS.DELETE)
-    def deleteFinished(self):
-        """Deletes all finished files and completly finished packages.
-
-        :return: list of deleted package ids
-        """
-        return self.core.files.deleteFinishedLinks()
-
-    @permission(PERMS.MODIFY)
-    def restartFailed(self):
-        """Restarts all failed failes."""
-        self.core.files.restartFailed()
-
-    @permission(PERMS.LIST)
-    def getPackageOrder(self, destination):
-        """Returns information about package order.
-
-        :param destination: `Destination`
-        :return: dict mapping order to package id
-        """
-
-        packs = self.core.files.getInfoData(destination)
-        order = {}
-
-        for pid in packs:
-            pack = self.core.files.getPackageData(int(pid))
-            while pack["order"] in order.keys(): #just in case
-                pack["order"] += 1
-            order[pack["order"]] = pack["id"]
-        return order
-
-    @permission(PERMS.LIST)
-    def getFileOrder(self, pid):
-        """Information about file order within package.
-
-        :param pid:
-        :return: dict mapping order to file id
-        """
-        rawData = self.core.files.getPackageData(int(pid))
-        order = {}
-        for id, pyfile in rawData["links"].iteritems():
-            while pyfile["order"] in order.keys(): #just in case
-                pyfile["order"] += 1
-            order[pyfile["order"]] = pyfile["id"]
-        return order
-
-
-    @permission(PERMS.STATUS)
-    def isCaptchaWaiting(self):
-        """Indicates wether a captcha task is available
-
-        :return: bool
-        """
-        self.core.lastClientConnected = time()
-        task = self.core.captchaManager.getTask()
-        return not task is None
-
-    @permission(PERMS.STATUS)
-    def getCaptchaTask(self, exclusive=False):
-        """Returns a captcha task
-
-        :param exclusive: unused
-        :return: `CaptchaTask`
-        """
-        self.core.lastClientConnected = time()
-        task = self.core.captchaManager.getTask()
-        if task:
-            task.setWatingForUser(exclusive=exclusive)
-            data, type, result = task.getCaptcha()
-            t = CaptchaTask(int(task.id), standard_b64encode(data), type, result)
-            return t
-        else:
-            return CaptchaTask(-1)
-
-    @permission(PERMS.STATUS)
-    def getCaptchaTaskStatus(self, tid):
-        """Get information about captcha task
-
-        :param tid: task id
-        :return: string
-        """
-        self.core.lastClientConnected = time()
-        t = self.core.captchaManager.getTaskByID(tid)
-        return t.getStatus() if t else ""
-
-    @permission(PERMS.STATUS)
-    def setCaptchaResult(self, tid, result):
-        """Set result for a captcha task
-
-        :param tid: task id
-        :param result: captcha result
-        """
-        self.core.lastClientConnected = time()
-        task = self.core.captchaManager.getTaskByID(tid)
-        if task:
-            task.setResult(result)
-            self.core.captchaManager.removeTask(task)
-
-
-    @permission(PERMS.STATUS)
-    def getEvents(self, uuid):
-        """Lists occured events, may be affected to changes in future.
-
-        :param uuid:
-        :return: list of `Events`
-        """
-        events = self.core.pullManager.getEvents(uuid)
-        newEvents = []
-
-        def convDest(d):
-            return Destination.Queue if d == "queue" else Destination.Collector
-
-        for e in events:
-            event = EventInfo()
-            event.eventname = e[0]
-            if e[0] in ("update", "remove", "insert"):
-                event.id = e[3]
-                event.type = ElementType.Package if e[2] == "pack" else ElementType.File
-                event.destination = convDest(e[1])
-            elif e[0] == "order":
-                if e[1]:
-                    event.id = e[1]
-                    event.type = ElementType.Package if e[2] == "pack" else ElementType.File
-                    event.destination = convDest(e[3])
-            elif e[0] == "reload":
-                event.destination = convDest(e[1])
-            newEvents.append(event)
-        return newEvents
-
-    @permission(PERMS.ACCOUNTS)
-    def getAccounts(self, refresh):
-        """Get information about all entered accounts.
-
-        :param refresh: reload account info
-        :return: list of `AccountInfo`
-        """
-        accs = self.core.accountManager.getAccountInfos(False, refresh)
-        accounts = []
-        for group in accs.values():
-            accounts.extend([AccountInfo(acc["validuntil"], acc["login"], acc["options"], acc["valid"],
-                                         acc["trafficleft"], acc["maxtraffic"], acc["premium"], acc["type"])
-                             for acc in group])
-        return accounts
-
-    @permission(PERMS.ALL)
-    def getAccountTypes(self):
-        """All available account types.
-
-        :return: list
-        """
-        return self.core.accountManager.accounts.keys()
-
-    @permission(PERMS.ACCOUNTS)
-    def updateAccount(self, plugin, account, password=None, options={}):
-        """Changes pw/options for specific account."""
-        self.core.accountManager.updateAccount(plugin, account, password, options)
-
-    @permission(PERMS.ACCOUNTS)
-    def removeAccount(self, plugin, account):
-        """Remove account from pyload.
-
-        :param plugin: pluginname
-        :param account: accountname
-        """
-        self.core.accountManager.removeAccount(plugin, account)
-
-    @permission(PERMS.ALL)
+    @RequirePerm(Permission.All)
     def login(self, username, password, remoteip=None):
         """Login into pyLoad, this **must** be called when using rpc before any methods can be used.
 
@@ -918,116 +146,61 @@ class Api(Iface):
 
         :param username:
         :param password:
-        :param remoteip: 
+        :param remoteip:
         :return: dict with info, empty when login is incorrect
         """
-        if self.core.config["remote"]["nolocalauth"] and remoteip == "127.0.0.1":
-            return "local"
-        if self.core.startedInGui and remoteip == "127.0.0.1":
-            return "local"
+        self.core.log.info(_("User '%s' tries to log in") % username)
 
         return self.core.db.checkAuth(username, password)
 
-    def isAuthorized(self, func, userdata):
+    def isAuthorized(self, func, user):
         """checks if the user is authorized for specific method
 
         :param func: function name
-        :param userdata: dictionary of user data
+        :param user: `User`
         :return: boolean
         """
-        if userdata == "local" or userdata["role"] == ROLE.ADMIN:
+        if user.isAdmin():
             return True
-        elif func in permMap and has_permission(userdata["permission"], permMap[func]):
+        elif func in perm_map and user.hasPermission(perm_map[func]):
             return True
         else:
             return False
 
-
-    @permission(PERMS.ALL)
+    # TODO
+    @RequirePerm(Permission.All)
     def getUserData(self, username, password):
         """similar to `checkAuth` but returns UserData thrift type """
-        user =  self.checkAuth(username, password)
-        if user:
-            return UserData(user["name"], user["email"], user["role"], user["permission"], user["template"])
-        else:
-            return UserData()
+        user = self.checkAuth(username, password)
+        if not user:
+            raise UserDoesNotExists(username)
 
+        return user.toUserData()
 
     def getAllUserData(self):
         """returns all known user and info"""
-        res = {}
-        for user, data in self.core.db.getAllUserData().iteritems():
-            res[user] = UserData(user, data["email"], data["role"], data["permission"], data["template"])
-
-        return res
-
-    @permission(PERMS.STATUS)
-    def getServices(self):
-        """ A dict of available services, these can be defined by hook plugins.
-
-        :return: dict with this style: {"plugin": {"method": "description"}}
-        """
-        data = {}
-        for plugin, funcs in self.core.hookManager.methods.iteritems():
-            data[plugin] = funcs
-
-        return data
-
-    @permission(PERMS.STATUS)
-    def hasService(self, plugin, func):
-        """Checks wether a service is available.
+        return self.core.db.getAllUserData()
 
-        :param plugin:
-        :param func:
-        :return: bool
-        """
-        cont = self.core.hookManager.methods
-        return plugin in cont and func in cont[plugin]
-
-    @permission(PERMS.STATUS)
-    def call(self, info):
-        """Calls a service (a method in hook plugin).
-
-        :param info: `ServiceCall`
-        :return: result
-        :raises: ServiceDoesNotExists, when its not available
-        :raises: ServiceException, when a exception was raised
-        """
-        plugin = info.plugin
-        func = info.func
-        args = info.arguments
-        parse = info.parseArguments
-
-        if not self.hasService(plugin, func):
-            raise ServiceDoesNotExists(plugin, func)
-
-        try:
-            ret = self.core.hookManager.callRPC(plugin, func, args, parse)
-            return str(ret)
-        except Exception, e:
-            raise ServiceException(e.message)
+    def changePassword(self, username, oldpw, newpw):
+        """ changes password for specific user """
+        return self.core.db.changePassword(username, oldpw, newpw)
 
-    @permission(PERMS.STATUS)
-    def getAllInfo(self):
-        """Returns all information stored by hook plugins. Values are always strings
+    def setUserPermission(self, user, permission, role):
+        self.core.db.setPermission(user, permission)
+        self.core.db.setRole(user, role)
 
-        :return: {"plugin": {"name": value } }
-        """
-        return self.core.hookManager.getAllInfo()
 
-    @permission(PERMS.STATUS)
-    def getInfoByPlugin(self, plugin):
-        """Returns information stored by a specific plugin.
+class UserApi(Api):
+    """  Proxy object for api that provides all methods in user context """
 
-        :param plugin: pluginname
-        :return: dict of attr names mapped to value {"name": value}
-        """
-        return self.core.hookManager.getInfo(plugin)
+    def __init__(self, core, user):
+        # No need to init super class
+        self.core = core
+        self._user = user
 
-    def changePassword(self, user, oldpw, newpw):
-        """ changes password for specific user """
-        return self.core.db.changePassword(user, oldpw, newpw)
+    def withUserContext(self, uid):
+        raise Exception("Not allowed")
 
-    def setUserPermission(self, user, permission, role):
-        self.core.db.setPermission(user, permission)
-        self.core.db.setRole(user, role)
\ No newline at end of file
+    @property
+    def user(self):
+        return self._user
\ No newline at end of file
diff --git a/module/CaptchaManager.py b/module/CaptchaManager.py
deleted file mode 100644
index 02cd10a11..000000000
--- a/module/CaptchaManager.py
+++ /dev/null
@@ -1,158 +0,0 @@
-# -*- coding: utf-8 -*-
-
-"""
-    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/>.
-    
-    @author: mkaay, RaNaN
-"""
-
-from time import time
-from traceback import print_exc
-from threading import Lock
-
-class CaptchaManager():
-    def __init__(self, core):
-        self.lock = Lock()
-        self.core = core
-        self.tasks = [] #task store, for outgoing tasks only
-
-        self.ids = 0 #only for internal purpose
-
-    def newTask(self, img, format, file, result_type):
-        task = CaptchaTask(self.ids, img, format, file, result_type)
-        self.ids += 1
-        return task
-
-    def removeTask(self, task):
-        self.lock.acquire()
-        if task in self.tasks:
-            self.tasks.remove(task)
-        self.lock.release()
-
-    def getTask(self):
-        self.lock.acquire()
-        for task in self.tasks:
-            if task.status in ("waiting", "shared-user"):
-                self.lock.release()
-                return task
-        self.lock.release()
-        return None
-
-    def getTaskByID(self, tid):
-        self.lock.acquire()
-        for task in self.tasks:
-            if task.id == str(tid): #task ids are strings
-                self.lock.release()
-                return task
-        self.lock.release()
-        return None
-
-    def handleCaptcha(self, task):
-        cli = self.core.isClientConnected()
-
-        if cli: #client connected -> should solve the captcha
-            task.setWaiting(50) #wait 50 sec for response
-
-        for plugin in self.core.hookManager.activePlugins():
-            try:
-                plugin.newCaptchaTask(task)
-            except:
-                if self.core.debug:
-                    print_exc()
-            
-        if task.handler or cli: #the captcha was handled
-            self.tasks.append(task)
-            return True
-
-        task.error = _("No Client connected for captcha decrypting")
-
-        return False
-
-
-class CaptchaTask():
-    def __init__(self, id, img, format, file, result_type='textual'):
-        self.id = str(id)
-        self.captchaImg = img
-        self.captchaFormat = format
-        self.captchaFile = file
-        self.captchaResultType = result_type
-        self.handler = [] #the hook plugins that will take care of the solution
-        self.result = None
-        self.waitUntil = None
-        self.error = None #error message
-
-        self.status = "init"
-        self.data = {} #handler can store data here
-
-    def getCaptcha(self):
-        return self.captchaImg, self.captchaFormat, self.captchaResultType
-
-    def setResult(self, text):
-        if self.isTextual():
-            self.result = text
-        if self.isPositional():
-            try:
-                parts = text.split(',')
-                self.result = (int(parts[0]), int(parts[1]))
-            except:
-                self.result = None
-
-    def getResult(self):
-        try:
-            res = self.result.encode("utf8", "replace")
-        except:
-            res = self.result
-
-        return res
-
-    def getStatus(self):
-        return self.status
-
-    def setWaiting(self, sec):
-        """ let the captcha wait secs for the solution """
-        self.waitUntil = max(time() + sec, self.waitUntil)
-        self.status = "waiting"
-
-    def isWaiting(self):
-        if self.result or self.error or time() > self.waitUntil:
-            return False
-
-        return True
-
-    def isTextual(self):
-        """ returns if text is written on the captcha """
-        return self.captchaResultType == 'textual'
-
-    def isPositional(self):
-        """ returns if user have to click a specific region on the captcha """
-        return self.captchaResultType == 'positional'
-
-    def setWatingForUser(self, exclusive):
-        if exclusive:
-            self.status = "user"
-        else:
-            self.status = "shared-user"
-
-    def timedOut(self):
-        return time() > self.waitUntil
-
-    def invalid(self):
-        """ indicates the captcha was not correct """
-        [x.captchaInvalid(self) for x in self.handler]
-
-    def correct(self):
-        [x.captchaCorrect(self) for x in self.handler]
-
-    def __str__(self):
-        return "<CaptchaTask '%s'>" % self.id
diff --git a/module/ConfigParser.py b/module/ConfigParser.py
deleted file mode 100644
index 78b612f13..000000000
--- a/module/ConfigParser.py
+++ /dev/null
@@ -1,392 +0,0 @@
-# -*- coding: utf-8 -*-
-
-from __future__ import with_statement
-from time import sleep
-from os.path import exists, join
-from shutil import copy
-
-from traceback import print_exc
-from utils import chmod
-
-# ignore these plugin configs, mainly because plugins were wiped out
-IGNORE = (
-    "FreakshareNet", "SpeedManager", "ArchiveTo", "ShareCx", ('hooks', 'UnRar'),
-    'EasyShareCom', 'FlyshareCz'
-    )
-
-CONF_VERSION = 1
-
-class ConfigParser:
-    """
-    holds and manage the configuration
-    
-    current dict layout:
-    
-    {
-    
-     section : { 
-      option : { 
-            value:
-            type:
-            desc:
-      }
-      desc: 
-    
-    }
-    
-    
-    """
-
-
-    def __init__(self):
-        """Constructor"""
-        self.config = {} # the config values
-        self.plugin = {} # the config for plugins
-        self.oldRemoteData = {}
-
-        self.pluginCB = None # callback when plugin config value is changed
-
-        self.checkVersion()
-
-        self.readConfig()
-
-        self.deleteOldPlugins()
-
-
-    def checkVersion(self, n=0):
-        """determines if config need to be copied"""
-        try:
-            if not exists("pyload.conf"):
-                copy(join(pypath, "module", "config", "default.conf"), "pyload.conf")
-
-            if not exists("plugin.conf"):
-                f = open("plugin.conf", "wb")
-                f.write("version: " + str(CONF_VERSION))
-                f.close()
-
-            f = open("pyload.conf", "rb")
-            v = f.readline()
-            f.close()
-            v = v[v.find(":") + 1:].strip()
-
-            if not v or int(v) < CONF_VERSION:
-                copy(join(pypath, "module", "config", "default.conf"), "pyload.conf")
-                print "Old version of config was replaced"
-
-            f = open("plugin.conf", "rb")
-            v = f.readline()
-            f.close()
-            v = v[v.find(":") + 1:].strip()
-
-            if not v or int(v) < CONF_VERSION:
-                f = open("plugin.conf", "wb")
-                f.write("version: " + str(CONF_VERSION))
-                f.close()
-                print "Old version of plugin-config replaced"
-        except:
-            if n < 3:
-                sleep(0.3)
-                self.checkVersion(n + 1)
-            else:
-                raise
-
-    def readConfig(self):
-        """reads the config file"""
-
-        self.config = self.parseConfig(join(pypath, "module", "config", "default.conf"))
-        self.plugin = self.parseConfig("plugin.conf")
-
-        try:
-            homeconf = self.parseConfig("pyload.conf")
-            if "username" in homeconf["remote"]:
-                if "password" in homeconf["remote"]:
-                    self.oldRemoteData = {"username": homeconf["remote"]["username"]["value"],
-                                          "password": homeconf["remote"]["username"]["value"]}
-                    del homeconf["remote"]["password"]
-                del homeconf["remote"]["username"]
-            self.updateValues(homeconf, self.config)
-
-        except Exception, e:
-            print "Config Warning"
-            print_exc()
-
-
-    def parseConfig(self, config):
-        """parses a given configfile"""
-
-        f = open(config)
-
-        config = f.read()
-
-        config = config.splitlines()[1:]
-
-        conf = {}
-
-        section, option, value, typ, desc = "", "", "", "", ""
-
-        listmode = False
-
-        for line in config:
-            comment = line.rfind("#")
-            if line.find(":", comment) < 0 > line.find("=", comment) and comment > 0 and line[comment - 1].isspace():
-                line = line.rpartition("#") # removes comments            
-                if line[1]:
-                    line = line[0]
-                else:
-                    line = line[2]
-
-            line = line.strip()
-
-            try:
-                if line == "":
-                    continue
-                elif line.endswith(":"):
-                    section, none, desc = line[:-1].partition('-')
-                    section = section.strip()
-                    desc = desc.replace('"', "").strip()
-                    conf[section] = {"desc": desc}
-                else:
-                    if listmode:
-                        if line.endswith("]"):
-                            listmode = False
-                            line = line.replace("]", "")
-
-                        value += [self.cast(typ, x.strip()) for x in line.split(",") if x]
-
-                        if not listmode:
-                            conf[section][option] = {"desc": desc,
-                                                     "type": typ,
-                                                     "value": value}
-
-
-                    else:
-                        content, none, value = line.partition("=")
-
-                        content, none, desc = content.partition(":")
-
-                        desc = desc.replace('"', "").strip()
-
-                        typ, none, option = content.strip().rpartition(" ")
-
-                        value = value.strip()
-
-                        if value.startswith("["):
-                            if value.endswith("]"):
-                                listmode = False
-                                value = value[:-1]
-                            else:
-                                listmode = True
-
-                            value = [self.cast(typ, x.strip()) for x in value[1:].split(",") if x]
-                        else:
-                            value = self.cast(typ, value)
-
-                        if not listmode:
-                            conf[section][option] = {"desc": desc,
-                                                     "type": typ,
-                                                     "value": value}
-
-            except Exception, e:
-                print "Config Warning"
-                print_exc()
-
-        f.close()
-        return conf
-
-
-    def updateValues(self, config, dest):
-        """sets the config values from a parsed config file to values in destination"""
-
-        for section in config.iterkeys():
-            if section in dest:
-                for option in config[section].iterkeys():
-                    if option in ("desc", "outline"): continue
-
-                    if option in dest[section]:
-                        dest[section][option]["value"] = config[section][option]["value"]
-
-                        #else:
-                        #    dest[section][option] = config[section][option]
-
-
-                        #else:
-                        #    dest[section] = config[section]
-
-    def saveConfig(self, config, filename):
-        """saves config to filename"""
-        with open(filename, "wb") as f:
-            chmod(filename, 0600)
-            f.write("version: %i \n" % CONF_VERSION)
-            for section in config.iterkeys():
-                f.write('\n%s - "%s":\n' % (section, config[section]["desc"]))
-
-                for option, data in config[section].iteritems():
-                    if option in ("desc", "outline"): continue
-
-                    if isinstance(data["value"], list):
-                        value = "[ \n"
-                        for x in data["value"]:
-                            value += "\t\t" + str(x) + ",\n"
-                        value += "\t\t]\n"
-                    else:
-                        if type(data["value"]) in (str, unicode):
-                            value = data["value"] + "\n"
-                        else:
-                            value = str(data["value"]) + "\n"
-                    try:
-                        f.write('\t%s %s : "%s" = %s' % (data["type"], option, data["desc"], value))
-                    except UnicodeEncodeError:
-                        f.write('\t%s %s : "%s" = %s' % (data["type"], option, data["desc"], value.encode("utf8")))
-
-    def cast(self, typ, value):
-        """cast value to given format"""
-        if type(value) not in (str, unicode):
-            return value
-
-        elif typ == "int":
-            return int(value)
-        elif typ == "bool":
-            return True if value.lower() in ("1", "true", "on", "an", "yes") else False
-        elif typ == "time":
-            if not value: value = "0:00"
-            if not ":" in value: value += ":00"
-            return value
-        elif typ in ("str", "file", "folder"):
-            try:
-                return value.encode("utf8")
-            except:
-                return value
-        else:
-            return value
-
-
-    def save(self):
-        """saves the configs to disk"""
-
-        self.saveConfig(self.config, "pyload.conf")
-        self.saveConfig(self.plugin, "plugin.conf")
-
-
-    def __getitem__(self, section):
-        """provides dictonary like access: c['section']['option']"""
-        return Section(self, section)
-
-
-    def get(self, section, option):
-        """get value"""
-        val = self.config[section][option]["value"]
-        try:
-            if type(val) in (str, unicode):
-                return val.decode("utf8")
-            else:
-                return val
-        except:
-            return val
-
-    def set(self, section, option, value):
-        """set value"""
-
-        value = self.cast(self.config[section][option]["type"], value)
-
-        self.config[section][option]["value"] = value
-        self.save()
-
-    def getPlugin(self, plugin, option):
-        """gets a value for a plugin"""
-        val = self.plugin[plugin][option]["value"]
-        try:
-            if type(val) in (str, unicode):
-                return val.decode("utf8")
-            else:
-                return val
-        except:
-            return val
-
-    def setPlugin(self, plugin, option, value):
-        """sets a value for a plugin"""
-
-        value = self.cast(self.plugin[plugin][option]["type"], value)
-
-        if self.pluginCB: self.pluginCB(plugin, option, value)
-
-        self.plugin[plugin][option]["value"] = value
-        self.save()
-
-    def getMetaData(self, section, option):
-        """ get all config data for an option """
-        return self.config[section][option]
-
-    def addPluginConfig(self, name, config, outline=""):
-        """adds config options with tuples (name, type, desc, default)"""
-        if name not in self.plugin:
-            conf = {"desc": name,
-                    "outline": outline}
-            self.plugin[name] = conf
-        else:
-            conf = self.plugin[name]
-            conf["outline"] = outline
-
-        for item in config:
-            if item[0] in conf:
-                conf[item[0]]["type"] = item[1]
-                conf[item[0]]["desc"] = item[2]
-            else:
-                conf[item[0]] = {
-                    "desc": item[2],
-                    "type": item[1],
-                    "value": self.cast(item[1], item[3])
-                }
-
-        values = [x[0] for x in config] + ["desc", "outline"]
-        #delete old values
-        for item in conf.keys():
-            if item not in values:
-                del conf[item]
-
-    def deleteConfig(self, name):
-        """Removes a plugin config"""
-        if name in self.plugin:
-            del self.plugin[name]
-
-
-    def deleteOldPlugins(self):
-        """ remove old plugins from config """
-
-        for name in IGNORE:
-            if name in self.plugin:
-                del self.plugin[name]
-
-
-class Section:
-    """provides dictionary like access for configparser"""
-
-    def __init__(self, parser, section):
-        """Constructor"""
-        self.parser = parser
-        self.section = section
-
-    def __getitem__(self, item):
-        """getitem"""
-        return self.parser.get(self.section, item)
-
-    def __setitem__(self, item, value):
-        """setitem"""
-        self.parser.set(self.section, item, value)
-
-
-if __name__ == "__main__":
-    pypath = ""
-
-    from time import time
-
-    a = time()
-
-    c = ConfigParser()
-
-    b = time()
-
-    print "sec", b - a
-
-    print c.config
-
-    c.saveConfig(c.config, "user.conf")
diff --git a/module/FileManager.py b/module/FileManager.py
new file mode 100644
index 000000000..7b14613f7
--- /dev/null
+++ b/module/FileManager.py
@@ -0,0 +1,582 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+###############################################################################
+#   Copyright(c) 2008-2012 pyLoad Team
+#   http://www.pyload.org
+#
+#   This file is part of pyLoad.
+#   pyLoad is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU Affero General Public License as
+#   published by the Free Software Foundation, either version 3 of the
+#   License, or (at your option) any later version.
+#
+#   Subjected to the terms and conditions in LICENSE
+#
+#   @author: RaNaN
+###############################################################################
+
+from time import time
+from ReadWriteLock import ReadWriteLock
+
+from module.utils import lock, read_lock
+
+from Api import PackageStatus, DownloadStatus as DS, TreeCollection, PackageDoesNotExists
+from datatypes.PyFile import PyFile
+from datatypes.PyPackage import PyPackage, RootPackage
+
+# invalidates the cache
+def invalidate(func):
+    def new(*args):
+        args[0].downloadstats = {}
+        args[0].queuestats = {}
+        args[0].jobCache = {}
+        return func(*args)
+
+    return new
+
+# TODO: needs to be replaced later
+OWNER = 0
+
+class FileManager:
+    """Handles all request made to obtain information,
+    modify status or other request for links or packages"""
+
+    ROOT_PACKAGE = -1
+
+    def __init__(self, core):
+        """Constructor"""
+        self.core = core
+        self.evm = core.eventManager
+
+        # translations
+        self.statusMsg = [_("none"), _("offline"), _("online"), _("queued"), _("paused"),
+                          _("finished"), _("skipped"), _("failed"), _("starting"),
+                          _("waiting"), _("downloading"), _("temp. offline"), _("aborted"),
+                          _("decrypting"), _("processing"), _("custom"), _("unknown")]
+
+        self.files = {} # holds instances for files
+        self.packages = {}  # same for packages
+
+        self.jobCache = {}
+
+        # locking the caches, db is already locked implicit
+        self.lock = ReadWriteLock()
+        #self.lock._Verbose__verbose = True
+
+        self.downloadstats = {} # cached dl stats
+        self.queuestats = {} # cached queue stats
+
+        self.db = self.core.db
+
+    def save(self):
+        """saves all data to backend"""
+        self.db.commit()
+
+    @read_lock
+    def syncSave(self):
+        """saves all data to backend and waits until all data are written"""
+        for pyfile in self.files.values():
+            pyfile.sync()
+
+        for pypack in self.packages.values():
+            pypack.sync()
+
+        self.db.syncSave()
+
+    def cachedFiles(self):
+        return self.files.values()
+
+    def cachedPackages(self):
+        return self.packages.values()
+
+    def getCollector(self):
+        pass
+
+    @invalidate
+    def addLinks(self, data, package):
+        """Add links, data = (plugin, url) tuple. Internal method should use API."""
+        self.db.addLinks(data, package, OWNER)
+        self.evm.dispatchEvent("package:updated", package)
+
+
+    @invalidate
+    def addPackage(self, name, folder, root, password, site, comment, paused):
+        """Adds a package to database"""
+        pid = self.db.addPackage(name, folder, root, password, site, comment,
+            PackageStatus.Paused if paused else PackageStatus.Ok, OWNER)
+        p = self.db.getPackageInfo(pid)
+
+        self.evm.dispatchEvent("package:inserted", pid, p.root, p.packageorder)
+        return pid
+
+
+    @lock
+    def getPackage(self, pid):
+        """return package instance"""
+        if pid == self.ROOT_PACKAGE:
+            return RootPackage(self, OWNER)
+        elif pid in self.packages:
+            pack = self.packages[pid]
+            pack.timestamp = time()
+            return pack
+        else:
+            info = self.db.getPackageInfo(pid, False)
+            if not info: return None
+
+            pack = PyPackage.fromInfoData(self, info)
+            self.packages[pid] = pack
+
+            return pack
+
+    @read_lock
+    def getPackageInfo(self, pid):
+        """returns dict with package information"""
+        if pid == self.ROOT_PACKAGE:
+            pack = RootPackage(self, OWNER).toInfoData()
+        elif pid in self.packages:
+            pack = self.packages[pid].toInfoData()
+            pack.stats = self.db.getStatsForPackage(pid)
+        else:
+            pack = self.db.getPackageInfo(pid)
+
+        if not pack: return None
+
+        # todo: what does this todo mean?!
+        #todo: fill child packs and files
+        packs = self.db.getAllPackages(root=pid)
+        if pid in packs: del packs[pid]
+        pack.pids = packs.keys()
+
+        files = self.db.getAllFiles(package=pid)
+        pack.fids = files.keys()
+
+        return pack
+
+    @lock
+    def getFile(self, fid):
+        """returns pyfile instance"""
+        if fid in self.files:
+            return self.files[fid]
+        else:
+            info = self.db.getFileInfo(fid)
+            if not info: return None
+
+            f = PyFile.fromInfoData(self, info)
+            self.files[fid] = f
+            return f
+
+    @read_lock
+    def getFileInfo(self, fid):
+        """returns dict with file information"""
+        if fid in self.files:
+            return self.files[fid].toInfoData()
+
+        return self.db.getFileInfo(fid)
+
+    @read_lock
+    def getTree(self, pid, full, state, search=None):
+        """  return a TreeCollection and fill the info data of containing packages.
+             optional filter only unfnished files
+        """
+        view = TreeCollection(pid)
+
+        # for depth=1, we don't need to retrieve all files/packages
+        root = pid if not full else None
+
+        packs = self.db.getAllPackages(root)
+        files = self.db.getAllFiles(package=root, state=state, search=search)
+
+        # updating from cache
+        for fid, f in self.files.iteritems():
+            if fid in files:
+                files[fid] = f.toInfoData()
+
+        # foreign pid, don't overwrite local pid !
+        for fpid, p in self.packages.iteritems():
+            if fpid in packs:
+                # copy the stats data
+                stats = packs[fpid].stats
+                packs[fpid] = p.toInfoData()
+                packs[fpid].stats = stats
+
+        # root package is not in database, create an instance
+        if pid == self.ROOT_PACKAGE:
+            view.root = RootPackage(self, OWNER).toInfoData()
+            packs[self.ROOT_PACKAGE] = view.root
+        elif pid in packs:
+            view.root = packs[pid]
+        else: # package does not exists
+            return view
+
+        # linear traversal over all data
+        for fpid, p in packs.iteritems():
+            if p.fids is None: p.fids = []
+            if p.pids is None: p.pids = []
+
+            root = packs.get(p.root, None)
+            if root:
+                if root.pids is None: root.pids = []
+                root.pids.append(fpid)
+
+        for fid, f in files.iteritems():
+            p = packs.get(f.package, None)
+            if p: p.fids.append(fid)
+
+
+        # cutting of tree is not good in runtime, only saves bandwidth
+        # need to remove some entries
+        if full and pid > -1:
+            keep = []
+            queue = [pid]
+            while queue:
+                fpid = queue.pop()
+                keep.append(fpid)
+                queue.extend(packs[fpid].pids)
+
+            # now remove unneeded data
+            for fpid in packs.keys():
+                if fpid not in keep:
+                    del packs[fpid]
+
+            for fid, f in files.items():
+                if f.package not in keep:
+                    del files[fid]
+
+        #remove root
+        del packs[pid]
+        view.files = files
+        view.packages = packs
+
+        return view
+
+
+    @lock
+    def getJob(self, occ):
+        """get suitable job"""
+
+        #TODO only accessed by one thread, should not need a lock
+        #TODO needs to be approved for new database
+        #TODO clean mess
+        #TODO improve selection of valid jobs
+
+        if occ in self.jobCache:
+            if self.jobCache[occ]:
+                id = self.jobCache[occ].pop()
+                if id == "empty":
+                    pyfile = None
+                    self.jobCache[occ].append("empty")
+                else:
+                    pyfile = self.getFile(id)
+            else:
+                jobs = self.db.getJob(occ)
+                jobs.reverse()
+                if not jobs:
+                    self.jobCache[occ].append("empty")
+                    pyfile = None
+                else:
+                    self.jobCache[occ].extend(jobs)
+                    pyfile = self.getFile(self.jobCache[occ].pop())
+
+        else:
+            self.jobCache = {} #better not caching to much
+            jobs = self.db.getJob(occ)
+            jobs.reverse()
+            self.jobCache[occ] = jobs
+
+            if not jobs:
+                self.jobCache[occ].append("empty")
+                pyfile = None
+            else:
+                pyfile = self.getFile(self.jobCache[occ].pop())
+
+
+        return pyfile
+
+    def getDownloadStats(self, user=None):
+        """ return number of downloads  """
+        if user not in self.downloadstats:
+            self.downloadstats[user] = self.db.downloadstats(user)
+
+        return self.downloadstats[user]
+
+    def getQueueStats(self, user=None, force=False):
+        """number of files that have to be processed, failed files will not be included"""
+        if user not in self.queuestats or force:
+            self.queuestats[user] = self.db.queuestats(user)
+
+        return self.queuestats[user]
+
+    def scanDownloadFolder(self):
+        pass
+
+    @lock
+    @invalidate
+    def deletePackage(self, pid):
+        """delete package and all contained links"""
+
+        p = self.getPackage(pid)
+        if not p: return
+
+        oldorder = p.packageorder
+        root = p.root
+
+        for pyfile in self.cachedFiles():
+            if pyfile.packageid == pid:
+                pyfile.abortDownload()
+
+        # TODO: delete child packages
+        # TODO: delete folder
+
+        self.db.deletePackage(pid)
+        self.releasePackage(pid)
+
+        for pack in self.cachedPackages():
+            if pack.root == root and pack.packageorder > oldorder:
+                pack.packageorder -= 1
+
+        self.evm.dispatchEvent("package:deleted", pid)
+
+    @lock
+    @invalidate
+    def deleteFile(self, fid):
+        """deletes links"""
+
+        f = self.getFile(fid)
+        if not f: return
+
+        pid = f.packageid
+        order = f.fileorder
+
+        if fid in self.core.threadManager.processingIds():
+            f.abortDownload()
+
+        # TODO: delete real file
+
+        self.db.deleteFile(fid, f.fileorder, f.packageid)
+        self.releaseFile(fid)
+
+        for pyfile in self.files.itervalues():
+            if pyfile.packageid == pid and pyfile.fileorder > order:
+                pyfile.fileorder -= 1
+
+        self.evm.dispatchEvent("file:deleted", fid, pid)
+
+    @lock
+    def releaseFile(self, fid):
+        """removes pyfile from cache"""
+        if fid in self.files:
+            del self.files[fid]
+
+    @lock
+    def releasePackage(self, pid):
+        """removes package from cache"""
+        if pid in self.packages:
+            del self.packages[pid]
+
+    def updateFile(self, pyfile):
+        """updates file"""
+        self.db.updateFile(pyfile)
+
+        # This event is thrown with pyfile or only fid
+        self.evm.dispatchEvent("file:updated", pyfile)
+
+    def updatePackage(self, pypack):
+        """updates a package"""
+        self.db.updatePackage(pypack)
+        self.evm.dispatchEvent("package:updated", pypack.pid)
+
+    @invalidate
+    def updateFileInfo(self, data, pid):
+        """ updates file info (name, size, status,[ hash,] url)"""
+        self.db.updateLinkInfo(data)
+        self.evm.dispatchEvent("package:updated", pid)
+
+    def checkAllLinksFinished(self):
+        """checks if all files are finished and dispatch event"""
+
+        # TODO: user context?
+        if not self.db.queuestats()[0]:
+            self.core.addonManager.dispatchEvent("download:allFinished")
+            self.core.log.debug("All downloads finished")
+            return True
+
+        return False
+
+    def checkAllLinksProcessed(self, fid=-1):
+        """checks if all files was processed and pyload would idle now, needs fid which will be ignored when counting"""
+
+        # reset count so statistic will update (this is called when dl was processed)
+        self.resetCount()
+
+        # TODO: user context?
+        if not self.db.processcount(fid):
+            self.core.addonManager.dispatchEvent("download:allProcessed")
+            self.core.log.debug("All downloads processed")
+            return True
+
+        return False
+
+    def checkPackageFinished(self, pyfile):
+        """ checks if package is finished and calls addonmanager """
+
+        ids = self.db.getUnfinished(pyfile.packageid)
+        if not ids or (pyfile.id in ids and len(ids) == 1):
+            if not pyfile.package().setFinished:
+                self.core.log.info(_("Package finished: %s") % pyfile.package().name)
+                self.core.addonManager.packageFinished(pyfile.package())
+                pyfile.package().setFinished = True
+
+    def resetCount(self):
+        self.queuecount = -1
+
+    @read_lock
+    @invalidate
+    def restartPackage(self, pid):
+        """restart package"""
+        for pyfile in self.cachedFiles():
+            if pyfile.packageid == pid:
+                self.restartFile(pyfile.id)
+
+        self.db.restartPackage(pid)
+
+        if pid in self.packages:
+            self.packages[pid].setFinished = False
+
+        self.evm.dispatchEvent("package:updated", pid)
+
+    @read_lock
+    @invalidate
+    def restartFile(self, fid):
+        """ restart file"""
+        if fid in self.files:
+            f = self.files[fid]
+            f.status = DS.Queued
+            f.name = f.url
+            f.error = ""
+            f.abortDownload()
+
+        self.db.restartFile(fid)
+        self.evm.dispatchEvent("file:updated", fid)
+
+
+    @lock
+    @invalidate
+    def orderPackage(self, pid, position):
+
+        p = self.getPackageInfo(pid)
+        self.db.orderPackage(pid, p.root, p.packageorder, position)
+
+        for pack in self.packages.itervalues():
+            if pack.root != p.root or pack.packageorder < 0: continue
+            if pack.pid == pid:
+                pack.packageorder = position
+            if p.packageorder > position:
+                if position <= pack.packageorder < p.packageorder:
+                    pack.packageorder += 1
+            elif p.order < position:
+                if position >= pack.packageorder > p.packageorder:
+                    pack.packageorder -= 1
+
+        self.db.commit()
+
+        self.evm.dispatchEvent("package:reordered", pid, position, p.root)
+
+    @lock
+    @invalidate
+    def orderFiles(self, fids, pid, position):
+
+        files = [self.getFileInfo(fid) for fid in fids]
+        orders = [f.fileorder for f in files]
+        if min(orders) + len(files) != max(orders) + 1:
+            raise Exception("Tried to reorder non continous block of files")
+
+        # minimum fileorder
+        f = reduce(lambda x,y: x if x.fileorder < y.fileorder else y, files)
+        order = f.fileorder
+
+        self.db.orderFiles(pid, fids, order, position)
+        diff = len(fids)
+
+        if f.fileorder > position:
+            for pyfile in self.files.itervalues():
+                if pyfile.packageid != f.package or pyfile.fileorder < 0: continue
+                if position <= pyfile.fileorder < f.fileorder:
+                    pyfile.fileorder += diff
+
+            for i, fid in enumerate(fids):
+                if fid in self.files:
+                    self.files[fid].fileorder = position + i
+
+        elif f.fileorder < position:
+            for pyfile in self.files.itervalues():
+                if pyfile.packageid != f.package or pyfile.fileorder < 0: continue
+                if position >= pyfile.fileorder >= f.fileorder+diff:
+                    pyfile.fileorder -= diff
+
+            for i, fid in enumerate(fids):
+                if fid in self.files:
+                    self.files[fid].fileorder = position -diff + i + 1
+
+        self.db.commit()
+
+        self.evm.dispatchEvent("file:reordered", pid)
+
+    @read_lock
+    @invalidate
+    def movePackage(self, pid, root):
+        """  move pid - root """
+
+        p = self.getPackageInfo(pid)
+        dest = self.getPackageInfo(root)
+        if not p: raise PackageDoesNotExists(pid)
+        if not dest: raise PackageDoesNotExists(root)
+
+        # cantor won't be happy if we put the package in itself
+        if pid == root or p.root == root: return False
+
+        # TODO move real folders
+
+        # we assume pack is not in use anyway, so we can release it
+        self.releasePackage(pid)
+        self.db.movePackage(p.root, p.packageorder, pid, root)
+
+        return True
+
+    @read_lock
+    @invalidate
+    def moveFiles(self, fids, pid):
+        """ move all fids to pid """
+
+        f = self.getFileInfo(fids[0])
+        if not f or f.package == pid:
+            return False
+        if not self.getPackageInfo(pid):
+            raise PackageDoesNotExists(pid)
+
+        # TODO move real files
+
+        self.db.moveFiles(f.package, fids, pid)
+
+        return True
+
+
+    @invalidate
+    def reCheckPackage(self, pid):
+        """ recheck links in package """
+        data = self.db.getPackageData(pid)
+
+        urls = []
+
+        for pyfile in data.itervalues():
+            if pyfile.status not in (DS.NA, DS.Finished, DS.Skipped):
+                urls.append((pyfile.url, pyfile.pluginname))
+
+        self.core.threadManager.createInfoThread(urls, pid)
+
+
+    @invalidate
+    def restartFailed(self):
+        """ restart all failed links """
+        # failed should not be in cache anymore, so working on db is sufficient
+        self.db.restartFailed()
diff --git a/module/HookManager.py b/module/HookManager.py
deleted file mode 100644
index 16f692d76..000000000
--- a/module/HookManager.py
+++ /dev/null
@@ -1,315 +0,0 @@
-# -*- coding: utf-8 -*-
-
-"""
-    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/>.
-
-    @author: RaNaN, mkaay
-    @interface-version: 0.1
-"""
-import __builtin__
-
-import traceback
-from thread import start_new_thread
-from threading import RLock
-
-from types import MethodType
-
-from module.PluginThread import HookThread
-from module.plugins.PluginManager import literal_eval
-from utils import lock
-
-class HookManager:
-    """Manages hooks, delegates and handles Events.
-
-        Every plugin can define events, \
-        but some very usefull events are called by the Core.
-        Contrary to overwriting hook methods you can use event listener,
-        which provides additional entry point in the control flow.
-        Only do very short tasks or use threads.
-
-        **Known Events:**
-        Most hook methods exists as events. These are the additional known events.
-
-        ===================== ============== ==================================
-        Name                     Arguments      Description
-        ===================== ============== ==================================
-        downloadPreparing     fid            A download was just queued and will be prepared now.
-        downloadStarts        fid            A plugin will immediately starts the download afterwards.
-        linksAdded            links, pid     Someone just added links, you are able to modify the links.
-        allDownloadsProcessed                Every link was handled, pyload would idle afterwards.
-        allDownloadsFinished                 Every download in queue is finished.
-        unrarFinished         folder, fname  An Unrar job finished
-        configChanged                        The config was changed via the api.
-        pluginConfigChanged                  The plugin config changed, due to api or internal process.
-        ===================== ============== ==================================
-
-        | Notes:
-        |    allDownloadsProcessed is *always* called before allDownloadsFinished.
-        |    configChanged is *always* called before pluginConfigChanged.
-
-
-    """
-
-    def __init__(self, core):
-        self.core = core
-        self.config = self.core.config
-
-        __builtin__.hookManager = self #needed to let hooks register themself
-
-        self.log = self.core.log
-        self.plugins = []
-        self.pluginMap = {}
-        self.methods = {} #dict of names and list of methods usable by rpc
-
-        self.events = {} # contains events
-
-        #registering callback for config event
-        self.config.pluginCB = MethodType(self.dispatchEvent, "pluginConfigChanged", basestring)
-
-        self.addEvent("pluginConfigChanged", self.manageHooks)
-
-        self.lock = RLock()
-        self.createIndex()
-
-    def try_catch(func):
-        def new(*args):
-            try:
-                return func(*args)
-            except Exception, e:
-                args[0].log.error(_("Error executing hooks: %s") % str(e))
-                if args[0].core.debug:
-                    traceback.print_exc()
-
-        return new
-
-
-    def addRPC(self, plugin, func, doc):
-        plugin = plugin.rpartition(".")[2]
-        doc = doc.strip() if doc else ""
-
-        if plugin in self.methods:
-            self.methods[plugin][func] = doc
-        else:
-            self.methods[plugin] = {func: doc}
-
-    def callRPC(self, plugin, func, args, parse):
-        if not args: args = tuple()
-        if parse:
-            args = tuple([literal_eval(x) for x in args])
-
-        plugin = self.pluginMap[plugin]
-        f = getattr(plugin, func)
-        return f(*args)
-
-
-    def createIndex(self):
-        plugins = []
-
-        active = []
-        deactive = []
-
-        for pluginname in self.core.pluginManager.hookPlugins:
-            try:
-                #hookClass = getattr(plugin, plugin.__name__)
-
-                if self.core.config.getPlugin(pluginname, "activated"):
-                    pluginClass = self.core.pluginManager.loadClass("hooks", pluginname)
-                    if not pluginClass: continue
-                    
-                    plugin = pluginClass(self.core, self)
-                    plugins.append(plugin)
-                    self.pluginMap[pluginClass.__name__] = plugin
-                    if plugin.isActivated():
-                        active.append(pluginClass.__name__)
-                else:
-                    deactive.append(pluginname)
-
-
-            except:
-                self.log.warning(_("Failed activating %(name)s") % {"name": pluginname})
-                if self.core.debug:
-                    traceback.print_exc()
-
-        self.log.info(_("Activated plugins: %s") % ", ".join(sorted(active)))
-        self.log.info(_("Deactivate plugins: %s") % ", ".join(sorted(deactive)))
-
-        self.plugins = plugins
-
-    def manageHooks(self, plugin, name, value):
-        if name == "activated" and value:
-            self.activateHook(plugin)
-        elif name == "activated" and not value:
-            self.deactivateHook(plugin)
-
-    def activateHook(self, plugin):
-
-        #check if already loaded
-        for inst in self.plugins:
-            if inst.__name__ == plugin:
-                return
-
-        pluginClass = self.core.pluginManager.loadClass("hooks", plugin)
-
-        if not pluginClass: return
-
-        self.log.debug("Plugin loaded: %s" % plugin)
-
-        plugin = pluginClass(self.core, self)
-        self.plugins.append(plugin)
-        self.pluginMap[pluginClass.__name__] = plugin
-
-        # call core Ready
-        start_new_thread(plugin.coreReady, tuple())
-
-    def deactivateHook(self, plugin):
-
-        hook = None
-        for inst in self.plugins:
-            if inst.__name__ == plugin:
-                hook = inst
-
-        if not hook: return
-
-        self.log.debug("Plugin unloaded: %s" % plugin)
-
-        hook.unload()
-
-        #remove periodic call
-        self.log.debug("Removed callback %s" % self.core.scheduler.removeJob(hook.cb))
-        self.plugins.remove(hook)
-        del self.pluginMap[hook.__name__]
-
-
-    @try_catch
-    def coreReady(self):
-        for plugin in self.plugins:
-            if plugin.isActivated():
-                plugin.coreReady()
-
-        self.dispatchEvent("coreReady")
-
-    @try_catch
-    def coreExiting(self):
-        for plugin in self.plugins:
-            if plugin.isActivated():
-                plugin.coreExiting()
-
-        self.dispatchEvent("coreExiting")
-
-    @lock
-    def downloadPreparing(self, pyfile):
-        for plugin in self.plugins:
-            if plugin.isActivated():
-                plugin.downloadPreparing(pyfile)
-
-        self.dispatchEvent("downloadPreparing", pyfile)
-
-    @lock
-    def downloadFinished(self, pyfile):
-        for plugin in self.plugins:
-            if plugin.isActivated():
-                if "downloadFinished" in plugin.__threaded__:
-                    self.startThread(plugin.downloadFinished, pyfile)
-                else:
-                    plugin.downloadFinished(pyfile)
-
-        self.dispatchEvent("downloadFinished", pyfile)
-
-    @lock
-    @try_catch
-    def downloadFailed(self, pyfile):
-        for plugin in self.plugins:
-            if plugin.isActivated():
-                if "downloadFailed" in plugin.__threaded__:
-                    self.startThread(plugin.downloadFinished, pyfile)
-                else:
-                    plugin.downloadFailed(pyfile)
-
-        self.dispatchEvent("downloadFailed", pyfile)
-
-    @lock
-    def packageFinished(self, package):
-        for plugin in self.plugins:
-            if plugin.isActivated():
-                if "packageFinished" in plugin.__threaded__:
-                    self.startThread(plugin.packageFinished, package)
-                else:
-                    plugin.packageFinished(package)
-
-        self.dispatchEvent("packageFinished", package)
-
-    @lock
-    def beforeReconnecting(self, ip):
-        for plugin in self.plugins:
-            plugin.beforeReconnecting(ip)
-
-        self.dispatchEvent("beforeReconnecting", ip)
-
-    @lock
-    def afterReconnecting(self, ip):
-        for plugin in self.plugins:
-            if plugin.isActivated():
-                plugin.afterReconnecting(ip)
-
-        self.dispatchEvent("afterReconnecting", ip)
-
-    def startThread(self, function, *args, **kwargs):
-        t = HookThread(self.core.threadManager, function, args, kwargs)
-
-    def activePlugins(self):
-        """ returns all active plugins """
-        return [x for x in self.plugins if x.isActivated()]
-
-    def getAllInfo(self):
-        """returns info stored by hook plugins"""
-        info = {}
-        for name, plugin in self.pluginMap.iteritems():
-            if plugin.info:
-                #copy and convert so str
-                info[name] = dict([(x, str(y) if not isinstance(y, basestring) else y) for x, y in plugin.info.iteritems()])
-        return info
-
-
-    def getInfo(self, plugin):
-        info = {}
-        if plugin in self.pluginMap and self.pluginMap[plugin].info:
-            info = dict([(x, str(y) if not isinstance(y, basestring) else y)
-                for x, y in self.pluginMap[plugin].info.iteritems()])
-
-        return info
-
-    def addEvent(self, event, func):
-        """Adds an event listener for event name"""
-        if event in self.events:
-            self.events[event].append(func)
-        else:
-            self.events[event] = [func]
-
-    def removeEvent(self, event, func):
-        """removes previously added event listener"""
-        if event in self.events:
-            self.events[event].remove(func)
-
-    def dispatchEvent(self, event, *args):
-        """dispatches event with args"""
-        if event in self.events:
-            for f in self.events[event]:
-                try:
-                    f(*args)
-                except Exception, e:
-                    self.log.warning("Error calling event handler %s: %s, %s, %s"
-                    % (event, f, args, str(e)))
-                    if self.core.debug:
-                        traceback.print_exc()
-    
diff --git a/module/InitHomeDir.py b/module/InitHomeDir.py
index 156c9f932..ccf525576 100644
--- a/module/InitHomeDir.py
+++ b/module/InitHomeDir.py
@@ -25,6 +25,7 @@ import sys
 from sys import argv, platform
 
 import __builtin__
+
 __builtin__.owd = path.abspath("") #original working directory
 __builtin__.pypath = path.abspath(path.join(__file__, "..", ".."))
 
@@ -52,24 +53,27 @@ else:
 
 __builtin__.homedir = homedir
 
-args = " ".join(argv[1:])
-
+configdir = None
+args = " ".join(argv)
 # dirty method to set configdir from commandline arguments
 if "--configdir=" in args:
-    pos = args.find("--configdir=")
-    end = args.find("-", pos + 12)
+    for arg in argv:
+        if arg.startswith("--configdir="):
+            configdir = arg.replace('--configdir=', '').strip()
+
+elif "nosetests" in args:
+    print "Running in test mode"
+    configdir = join(pypath, "tests", "config")
 
-    if end == -1:
-        configdir = args[pos + 12:].strip()
-    else:
-        configdir = args[pos + 12:end].strip()
 elif path.exists(path.join(pypath, "module", "config", "configdir")):
     f = open(path.join(pypath, "module", "config", "configdir"), "rb")
     c = f.read().strip()
     f.close()
     configdir = path.join(pypath, c)
-else:
-    if platform in ("posix", "linux2"):
+
+# default config dir
+if not configdir:
+    if platform in ("posix", "linux2", "darwin"):
         configdir = path.join(homedir, ".pyload")
     else:
         configdir = path.join(homedir, "pyload")
diff --git a/module/PluginManager.py b/module/PluginManager.py
new file mode 100644
index 000000000..dac857059
--- /dev/null
+++ b/module/PluginManager.py
@@ -0,0 +1,407 @@
+# -*- coding: utf-8 -*-
+
+###############################################################################
+#   Copyright(c) 2008-2013 pyLoad Team
+#   http://www.pyload.org
+#
+#   This file is part of pyLoad.
+#   pyLoad is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU Affero General Public License as
+#   published by the Free Software Foundation, either version 3 of the
+#   License, or (at your option) any later version.
+#
+#   Subjected to the terms and conditions in LICENSE
+#
+#   @author: RaNaN, mkaay
+###############################################################################
+
+import re
+import sys
+
+from os import listdir, makedirs
+from os.path import isfile, join, exists, abspath, basename
+from sys import version_info
+from time import time
+
+from module.lib.SafeEval import const_eval as literal_eval
+from module.plugins.Base import Base
+
+from new_collections import namedtuple
+
+#TODO: ignores not updatable
+
+# ignore these plugin configs, mainly because plugins were wiped out
+IGNORE = (
+    "FreakshareNet", "SpeedManager", "ArchiveTo", "ShareCx", ('addons', 'UnRar'),
+    'EasyShareCom', 'FlyshareCz'
+    )
+
+PluginTuple = namedtuple("PluginTuple", "version re deps category user path")
+
+class PluginManager:
+    ROOT = "module.plugins."
+    USERROOT = "userplugins."
+    TYPES = ("crypter", "hoster", "accounts", "addons", "internal")
+
+    BUILTIN = re.compile(r'__(?P<attr>[a-z0-9_]+)__\s*=\s?(True|False|None|[0-9x.]+)', re.I)
+    SINGLE = re.compile(r'__(?P<attr>[a-z0-9_]+)__\s*=\s*(?:r|u|_)?((?:(?<!")"(?!")|\'|\().*(?:(?<!")"(?!")|\'|\)))',
+        re.I)
+    # note the nongreedy character: that means we can not embed list and dicts
+    MULTI = re.compile(r'__(?P<attr>[a-z0-9_]+)__\s*=\s*((?:\{|\[|"{3}).*?(?:"""|\}|\]))', re.DOTALL | re.M | re.I)
+
+    NO_MATCH = re.compile(r'^no_match$')
+
+    def __init__(self, core):
+        self.core = core
+
+        #self.config = self.core.config
+        self.log = core.log
+
+        self.plugins = {}
+        self.modules = {} # cached modules
+        self.history = [] # match history to speedup parsing (type, name)
+        self.user_context = {} # plugins working with user context
+        self.createIndex()
+
+        #register for import addon
+        sys.meta_path.append(self)
+
+    def logDebug(self, type, plugin, msg):
+        self.log.debug("Plugin %s | %s: %s" % (type, plugin, msg))
+
+    def createIndex(self):
+        """create information for all plugins available"""
+        # add to path, so we can import from userplugins
+        sys.path.append(abspath(""))
+
+        if not exists("userplugins"):
+            makedirs("userplugins")
+        if not exists(join("userplugins", "__init__.py")):
+            f = open(join("userplugins", "__init__.py"), "wb")
+            f.close()
+
+        a = time()
+        for type in self.TYPES:
+            self.plugins[type] = self.parse(type)
+
+        self.log.debug("Created index of plugins in %.2f ms", (time() - a) * 1000)
+
+    def parse(self, folder, home=None):
+        """  Analyze and parses all plugins in folder """
+        plugins = {}
+        if home:
+            pfolder = join("userplugins", folder)
+            if not exists(pfolder):
+                makedirs(pfolder)
+            if not exists(join(pfolder, "__init__.py")):
+                f = open(join(pfolder, "__init__.py"), "wb")
+                f.close()
+
+        else:
+            pfolder = join(pypath, "module", "plugins", folder)
+
+        for f in listdir(pfolder):
+            if (isfile(join(pfolder, f)) and f.endswith(".py") or f.endswith("_25.pyc") or f.endswith(
+                "_26.pyc") or f.endswith("_27.pyc")) and not f.startswith("_"):
+                if f.endswith("_25.pyc") and version_info[0:2] != (2, 5):
+                    continue
+                elif f.endswith("_26.pyc") and version_info[0:2] != (2, 6):
+                    continue
+                elif f.endswith("_27.pyc") and version_info[0:2] != (2, 7):
+                    continue
+
+                # replace suffix and version tag
+                name = f[:-3]
+                if name[-1] == ".": name = name[:-4]
+
+                plugin = self.parsePlugin(join(pfolder, f), folder, name, home)
+                if plugin:
+                    plugins[name] = plugin
+
+        if not home:
+            temp = self.parse(folder, plugins)
+            plugins.update(temp)
+
+        return plugins
+
+    def parseAttributes(self, filename, name, folder=""):
+        """ Parse attribute dict from plugin"""
+        data = open(filename, "rb")
+        content = data.read()
+        data.close()
+
+        attrs = {}
+        for m in self.BUILTIN.findall(content) + self.SINGLE.findall(content) + self.MULTI.findall(content):
+            #replace gettext function and eval result
+            try:
+                attrs[m[0]] = literal_eval(m[-1].replace("_(", "("))
+            except:
+                self.logDebug(folder, name, "Error when parsing: %s" % m[-1])
+                self.core.print_exc()
+
+            if not hasattr(Base, "__%s__" % m[0]):
+                if m[0] != "type": #TODO remove type from all plugins, its not needed
+                    self.logDebug(folder, name, "Unknown attribute '%s'" % m[0])
+
+        return attrs
+
+    def parsePlugin(self, filename, folder, name, home=None):
+        """  Parses a plugin from disk, folder means plugin type in this context. Also sets config.
+
+        :arg home: dict with plugins, of which the found one will be matched against (according version)
+        :returns PluginTuple"""
+
+        attrs = self.parseAttributes(filename, name, folder)
+        if not attrs: return
+
+        version = 0
+
+        if "version" in attrs:
+            try:
+                version = float(attrs["version"])
+            except ValueError:
+                self.logDebug(folder, name, "Invalid version %s" % attrs["version"])
+                version = 9 #TODO remove when plugins are fixed, causing update loops
+        else:
+            self.logDebug(folder, name, "No version attribute")
+
+        # home contains plugins from pyload root
+        if home and name in home:
+            if home[name].version >= version:
+                return
+
+        if name in IGNORE or (folder, name) in IGNORE:
+            return
+
+        if "pattern" in attrs and attrs["pattern"]:
+            try:
+                plugin_re = re.compile(attrs["pattern"], re.I)
+            except:
+                self.logDebug(folder, name, "Invalid regexp pattern '%s'" % attrs["pattern"])
+                plugin_re = self.NO_MATCH
+        else: plugin_re = self.NO_MATCH
+
+        deps = attrs.get("dependencies", None)
+        category = attrs.get("category", None) if folder == "addons" else None
+
+        # create plugin tuple
+        plugin = PluginTuple(version, plugin_re, deps, category, bool(home), filename)
+
+        # internals have no config
+        if folder == "internal":
+            return plugin
+
+        if folder == "addons" and "config" not in attrs and not attrs.get("internal", False):
+            attrs["config"] = (["activated", "bool", "Activated", False],)
+
+        if "config" in attrs and attrs["config"]:
+            config = attrs["config"]
+            desc = attrs.get("description", "")
+            long_desc = attrs.get("long_description", "")
+
+            if type(config[0]) == tuple:
+                config = [list(x) for x in config]
+            else:
+                config = [list(config)]
+
+            if folder == "addons" and not attrs.get("internal", False):
+                for item in config:
+                    if item[0] == "activated": break
+                else: # activated flag missing
+                    config.insert(0, ("activated", "bool", "Activated", False))
+
+            # Everything that is no addon and user_context=True, is added to dict
+            if folder != "addons" or attrs.get("user_context", False):
+                self.user_context[name] = True
+
+            try:
+                self.core.config.addConfigSection(name, name, desc, long_desc, config)
+            except:
+                self.logDebug(folder, name, "Invalid config  %s" % config)
+
+        return plugin
+
+
+    def parseUrls(self, urls):
+        """parse plugins for given list of urls, separate to crypter and hoster"""
+
+        res = {"hoster": [], "crypter": []} # tupels of (url, plugin)
+
+        for url in urls:
+            if type(url) not in (str, unicode, buffer):
+                self.log.debug("Parsing invalid type %s" % type(url))
+                continue
+
+            found = False
+
+            for ptype, name in self.history:
+                if self.plugins[ptype][name].re.match(url):
+                    res[ptype].append((url, name))
+                    found = (ptype, name)
+                    break # need to exit this loop first
+
+            if found:  # found match
+                if self.history[0] != found: #update history
+                    self.history.remove(found)
+                    self.history.insert(0, found)
+                continue
+
+            for ptype in ("crypter", "hoster"):
+                for name, plugin in self.plugins[ptype].iteritems():
+                    if plugin.re.match(url):
+                        res[ptype].append((url, name))
+                        self.history.insert(0, (ptype, name))
+                        del self.history[10:] # cut down to size of 10
+                        found = True
+                        break
+
+            if not found:
+                res["hoster"].append((url, "BasePlugin"))
+
+        return res["hoster"], res["crypter"]
+
+    def getPlugins(self, type):
+        return self.plugins.get(type, None)
+
+    def findPlugin(self, name, pluginlist=("hoster", "crypter")):
+        for ptype in pluginlist:
+            if name in self.plugins[ptype]:
+                return ptype, self.plugins[ptype][name]
+        return None, None
+
+    def getPluginModule(self, name):
+        """ Decprecated: return plugin module from hoster|crypter"""
+        self.log.debug("Deprecated method: .getPluginModule()")
+        type, plugin = self.findPlugin(name)
+        return self.loadModule(type, name)
+
+    def getPluginClass(self, name):
+        """ return plugin class from hoster|crypter, always the not overwritten one """
+        type, plugin = self.findPlugin(name)
+        return self.loadClass(type, name)
+
+    #  MultiHoster will overwrite this
+    getPlugin = getPluginClass
+
+    def loadAttributes(self, type, name):
+        plugin = self.plugins[type][name]
+        return self.parseAttributes(plugin.path, name, type)
+
+    def loadModule(self, type, name):
+        """ Returns loaded module for plugin
+
+        :param type: plugin type, subfolder of module.plugins
+        :param name:
+        """
+        plugins = self.plugins[type]
+        if name in plugins:
+            if (type, name) in self.modules: return self.modules[(type, name)]
+            try:
+                # convert path to python recognizable import
+                path = basename(plugins[name].path).replace(".pyc", "").replace(".py", "")
+                module = __import__(self.ROOT + "%s.%s" % (type, path), globals(), locals(), path)
+                self.modules[(type, name)] = module # cache import, maybe unneeded
+                return module
+            except Exception, e:
+                self.log.error(_("Error importing %(name)s: %(msg)s") % {"name": name, "msg": str(e)})
+                self.core.print_exc()
+
+    def loadClass(self, type, name):
+        """Returns the class of a plugin with the same name"""
+        module = self.loadModule(type, name)
+        if module: return getattr(module, name)
+
+    def find_module(self, fullname, path=None):
+        #redirecting imports if necesarry
+        if fullname.startswith(self.ROOT) or fullname.startswith(self.USERROOT): #separate pyload plugins
+            if fullname.startswith(self.USERROOT): user = 1
+            else: user = 0 #used as bool and int
+
+            split = fullname.split(".")
+            if len(split) != 4 - user: return
+            type, name = split[2 - user:4 - user]
+
+            if type in self.plugins and name in self.plugins[type]:
+                #userplugin is a newer version
+                if not user and self.plugins[type][name].user:
+                    return self
+                    #imported from userdir, but pyloads is newer
+                if user and not self.plugins[type][name].user:
+                    return self
+
+    def load_module(self, name, replace=True):
+        if name not in sys.modules:  #could be already in modules
+            if replace:
+                if self.ROOT in name:
+                    newname = name.replace(self.ROOT, self.USERROOT)
+                else:
+                    newname = name.replace(self.USERROOT, self.ROOT)
+            else: newname = name
+
+            base, plugin = newname.rsplit(".", 1)
+
+            self.log.debug("Redirected import %s -> %s" % (name, newname))
+
+            module = __import__(newname, globals(), locals(), [plugin])
+            #inject under new an old name
+            sys.modules[name] = module
+            sys.modules[newname] = module
+
+        return sys.modules[name]
+
+    def reloadPlugins(self, type_plugins):
+        """ reloads and reindexes plugins """
+        if not type_plugins: return False
+
+        self.log.debug("Request reload of plugins: %s" % type_plugins)
+
+        as_dict = {}
+        for t, n in type_plugins:
+            if t in as_dict:
+                as_dict[t].append(n)
+            else:
+                as_dict[t] = [n]
+
+        # we do not reload addons or internals, would cause to much side effects
+        if "addons" in as_dict or "internal" in as_dict:
+            return False
+
+        for type in as_dict.iterkeys():
+            for plugin in as_dict[type]:
+                if plugin in self.plugins[type]:
+                    if (type, plugin) in self.modules:
+                        self.log.debug("Reloading %s" % plugin)
+                        reload(self.modules[(type, plugin)])
+
+        # index re-creation
+        for type in ("crypter", "container", "hoster", "captcha", "accounts"):
+            self.plugins[type] = self.parse(type)
+
+        if "accounts" in as_dict: #accounts needs to be reloaded
+            self.core.accountManager.initPlugins()
+            self.core.scheduler.addJob(0, self.core.accountManager.getAccountInfos)
+
+        return True
+
+    def isUserPlugin(self, plugin):
+        """ A plugin suitable for multiple user """
+        return plugin in self.user_context
+
+    def isPluginType(self, plugin, type):
+        return plugin in self.plugins[type]
+
+    def getCategory(self, plugin):
+        if plugin in self.plugins["addons"]:
+            return self.plugins["addons"][plugin] or "addon"
+
+    def loadIcon(self, name):
+        """ load icon for single plugin, base64 encoded"""
+        pass
+
+    def checkDependencies(self, type, name):
+        """ Check deps for given plugin
+
+        :return: List of unfullfilled dependencies
+        """
+        pass
+    
diff --git a/module/PluginThread.py b/module/PluginThread.py
deleted file mode 100644
index 56c36c778..000000000
--- a/module/PluginThread.py
+++ /dev/null
@@ -1,677 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-"""
-    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/>.
-
-    @author: RaNaN
-"""
-
-from Queue import Queue
-from threading import Thread
-from os import listdir, stat
-from os.path import join
-from time import sleep, time, strftime, gmtime
-from traceback import print_exc, format_exc
-from pprint import pformat
-from sys import exc_info, exc_clear
-from copy import copy
-from types import MethodType
-
-from pycurl import error
-
-from PyFile import PyFile
-from plugins.Plugin import Abort, Fail, Reconnect, Retry, SkipDownload
-from common.packagetools import parseNames
-from utils import save_join
-from Api import OnlineStatus
-
-class PluginThread(Thread):
-    """abstract base class for thread types"""
-
-    #----------------------------------------------------------------------
-    def __init__(self, manager):
-        """Constructor"""
-        Thread.__init__(self)
-        self.setDaemon(True)
-        self.m = manager #thread manager
-
-
-    def writeDebugReport(self, pyfile):
-        """ writes a
-        :return:
-        """
-
-        dump_name = "debug_%s_%s.zip" % (pyfile.pluginname, strftime("%d-%m-%Y_%H-%M-%S"))
-        dump = self.getDebugDump(pyfile)
-
-        try:
-            import zipfile
-
-            zip = zipfile.ZipFile(dump_name, "w")
-
-            for f in listdir(join("tmp", pyfile.pluginname)):
-                try:
-                    # avoid encoding errors
-                    zip.write(join("tmp", pyfile.pluginname, f), save_join(pyfile.pluginname, f))
-                except:
-                    pass
-
-            info = zipfile.ZipInfo(save_join(pyfile.pluginname, "debug_Report.txt"), gmtime())
-            info.external_attr = 0644 << 16L # change permissions
-
-            zip.writestr(info, dump)
-            zip.close()
-
-            if not stat(dump_name).st_size:
-                raise Exception("Empty Zipfile")
-
-        except Exception, e:
-            self.m.log.debug("Error creating zip file: %s" % e)
-
-            dump_name = dump_name.replace(".zip", ".txt")
-            f = open(dump_name, "wb")
-            f.write(dump)
-            f.close()
-
-        self.m.core.log.info("Debug Report written to %s" % dump_name)
-
-    def getDebugDump(self, pyfile):
-        dump = "pyLoad %s Debug Report of %s %s \n\nTRACEBACK:\n %s \n\nFRAMESTACK:\n" % (
-            self.m.core.api.getServerVersion(), pyfile.pluginname, pyfile.plugin.__version__, format_exc())
-
-        tb = exc_info()[2]
-        stack = []
-        while tb:
-            stack.append(tb.tb_frame)
-            tb = tb.tb_next
-
-        for frame in stack[1:]:
-            dump += "\nFrame %s in %s at line %s\n" % (frame.f_code.co_name,
-                                                       frame.f_code.co_filename,
-                                                       frame.f_lineno)
-
-            for key, value in frame.f_locals.items():
-                dump += "\t%20s = " % key
-                try:
-                    dump += pformat(value) + "\n"
-                except Exception, e:
-                    dump += "<ERROR WHILE PRINTING VALUE> " + str(e) + "\n"
-
-            del frame
-
-        del stack #delete it just to be sure...
-
-        dump += "\n\nPLUGIN OBJECT DUMP: \n\n"
-
-        for name in dir(pyfile.plugin):
-            attr = getattr(pyfile.plugin, name)
-            if not name.endswith("__") and type(attr) != MethodType:
-                dump += "\t%20s = " % name
-                try:
-                    dump += pformat(attr) + "\n"
-                except Exception, e:
-                    dump += "<ERROR WHILE PRINTING VALUE> " + str(e) + "\n"
-
-        dump += "\nPYFILE OBJECT DUMP: \n\n"
-
-        for name in dir(pyfile):
-            attr = getattr(pyfile, name)
-            if not name.endswith("__") and type(attr) != MethodType:
-                dump += "\t%20s = " % name
-                try:
-                    dump += pformat(attr) + "\n"
-                except Exception, e:
-                    dump += "<ERROR WHILE PRINTING VALUE> " + str(e) + "\n"
-
-        if pyfile.pluginname in self.m.core.config.plugin:
-            dump += "\n\nCONFIG: \n\n"
-            dump += pformat(self.m.core.config.plugin[pyfile.pluginname]) + "\n"
-
-        return dump
-
-    def clean(self, pyfile):
-        """ set thread unactive and release pyfile """
-        self.active = False
-        pyfile.release()
-
-
-class DownloadThread(PluginThread):
-    """thread for downloading files from 'real' hoster plugins"""
-
-    #----------------------------------------------------------------------
-    def __init__(self, manager):
-        """Constructor"""
-        PluginThread.__init__(self, manager)
-
-        self.queue = Queue() # job queue
-        self.active = False
-
-        self.start()
-
-    #----------------------------------------------------------------------
-    def run(self):
-        """run method"""
-        pyfile = None
-
-        while True:
-            del pyfile
-            self.active = self.queue.get()
-            pyfile = self.active
-
-            if self.active == "quit":
-                self.active = False
-                self.m.threads.remove(self)
-                return True
-
-            try:
-                if not pyfile.hasPlugin(): continue
-                #this pyfile was deleted while queueing
-
-                pyfile.plugin.checkForSameFiles(starting=True)
-                self.m.log.info(_("Download starts: %s" % pyfile.name))
-
-                # start download
-                self.m.core.hookManager.downloadPreparing(pyfile)
-                pyfile.plugin.preprocessing(self)
-
-                self.m.log.info(_("Download finished: %s") % pyfile.name)
-                self.m.core.hookManager.downloadFinished(pyfile)
-                self.m.core.files.checkPackageFinished(pyfile)
-
-            except NotImplementedError:
-                self.m.log.error(_("Plugin %s is missing a function.") % pyfile.pluginname)
-                pyfile.setStatus("failed")
-                pyfile.error = "Plugin does not work"
-                self.clean(pyfile)
-                continue
-
-            except Abort:
-                try:
-                    self.m.log.info(_("Download aborted: %s") % pyfile.name)
-                except:
-                    pass
-
-                pyfile.setStatus("aborted")
-
-                self.clean(pyfile)
-                continue
-
-            except Reconnect:
-                self.queue.put(pyfile)
-                #pyfile.req.clearCookies()
-
-                while self.m.reconnecting.isSet():
-                    sleep(0.5)
-
-                continue
-
-            except Retry, e:
-                reason = e.args[0]
-                self.m.log.info(_("Download restarted: %(name)s | %(msg)s") % {"name": pyfile.name, "msg": reason})
-                self.queue.put(pyfile)
-                continue
-
-            except Fail, e:
-                msg = e.args[0]
-
-                if msg == "offline":
-                    pyfile.setStatus("offline")
-                    self.m.log.warning(_("Download is offline: %s") % pyfile.name)
-                elif msg == "temp. offline":
-                    pyfile.setStatus("temp. offline")
-                    self.m.log.warning(_("Download is temporary offline: %s") % pyfile.name)
-                else:
-                    pyfile.setStatus("failed")
-                    self.m.log.warning(_("Download failed: %(name)s | %(msg)s") % {"name": pyfile.name, "msg": msg})
-                    pyfile.error = msg
-
-                self.m.core.hookManager.downloadFailed(pyfile)
-                self.clean(pyfile)
-                continue
-
-            except error, e:
-                if len(e.args) == 2:
-                    code, msg = e.args
-                else:
-                    code = 0
-                    msg = e.args
-
-                self.m.log.debug("pycurl exception %s: %s" % (code, msg))
-
-                if code in (7, 18, 28, 52, 56):
-                    self.m.log.warning(_("Couldn't connect to host or connection reset, waiting 1 minute and retry."))
-                    wait = time() + 60
-
-                    pyfile.waitUntil = wait
-                    pyfile.setStatus("waiting")
-                    while time() < wait:
-                        sleep(1)
-                        if pyfile.abort:
-                            break
-
-                    if pyfile.abort:
-                        self.m.log.info(_("Download aborted: %s") % pyfile.name)
-                        pyfile.setStatus("aborted")
-
-                        self.clean(pyfile)
-                    else:
-                        self.queue.put(pyfile)
-
-                    continue
-
-                else:
-                    pyfile.setStatus("failed")
-                    self.m.log.error("pycurl error %s: %s" % (code, msg))
-                    if self.m.core.debug:
-                        print_exc()
-                        self.writeDebugReport(pyfile)
-
-                    self.m.core.hookManager.downloadFailed(pyfile)
-
-                self.clean(pyfile)
-                continue
-
-            except SkipDownload, e:
-                pyfile.setStatus("skipped")
-
-                self.m.log.info(
-                    _("Download skipped: %(name)s due to %(plugin)s") % {"name": pyfile.name, "plugin": e.message})
-
-                self.clean(pyfile)
-
-                self.m.core.files.checkPackageFinished(pyfile)
-
-                self.active = False
-                self.m.core.files.save()
-
-                continue
-
-
-            except Exception, e:
-                pyfile.setStatus("failed")
-                self.m.log.warning(_("Download failed: %(name)s | %(msg)s") % {"name": pyfile.name, "msg": str(e)})
-                pyfile.error = str(e)
-
-                if self.m.core.debug:
-                    print_exc()
-                    self.writeDebugReport(pyfile)
-
-                self.m.core.hookManager.downloadFailed(pyfile)
-                self.clean(pyfile)
-                continue
-
-            finally:
-                self.m.core.files.save()
-                pyfile.checkIfProcessed()
-                exc_clear()
-
-            
-            #pyfile.plugin.req.clean()
-
-            self.active = False
-            pyfile.finishIfDone()
-            self.m.core.files.save()
-
-
-    def put(self, job):
-        """assing job to thread"""
-        self.queue.put(job)
-
-
-    def stop(self):
-        """stops the thread"""
-        self.put("quit")
-
-
-class DecrypterThread(PluginThread):
-    """thread for decrypting"""
-
-    def __init__(self, manager, pyfile):
-        """constructor"""
-        PluginThread.__init__(self, manager)
-
-        self.active = pyfile
-        manager.localThreads.append(self)
-
-        pyfile.setStatus("decrypting")
-
-        self.start()
-
-    def getActiveFiles(self):
-        return [self.active]
-
-    def run(self):
-        """run method"""
-
-        pyfile = self.active
-        retry = False
-
-        try:
-            self.m.log.info(_("Decrypting starts: %s") % self.active.name)
-            self.active.plugin.preprocessing(self)
-
-        except NotImplementedError:
-            self.m.log.error(_("Plugin %s is missing a function.") % self.active.pluginname)
-            return
-
-        except Fail, e:
-            msg = e.args[0]
-
-            if msg == "offline":
-                self.active.setStatus("offline")
-                self.m.log.warning(_("Download is offline: %s") % self.active.name)
-            else:
-                self.active.setStatus("failed")
-                self.m.log.error(_("Decrypting failed: %(name)s | %(msg)s") % {"name": self.active.name, "msg": msg})
-                self.active.error = msg
-
-            return
-
-        except Abort:
-            self.m.log.info(_("Download aborted: %s") % pyfile.name)
-            pyfile.setStatus("aborted")
-
-            return
-
-        except Retry:
-            self.m.log.info(_("Retrying %s") % self.active.name)
-            retry = True
-            return self.run()
-
-        except Exception, e:
-            self.active.setStatus("failed")
-            self.m.log.error(_("Decrypting failed: %(name)s | %(msg)s") % {"name": self.active.name, "msg": str(e)})
-            self.active.error = str(e)
-
-            if self.m.core.debug:
-                print_exc()
-                self.writeDebugReport(pyfile)
-
-            return
-
-
-        finally:
-            if not retry:
-                self.active.release()
-                self.active = False
-                self.m.core.files.save()
-                self.m.localThreads.remove(self)
-                exc_clear()
-
-
-        #self.m.core.hookManager.downloadFinished(pyfile)
-
-
-        #self.m.localThreads.remove(self)
-        #self.active.finishIfDone()
-        if not retry:
-            pyfile.delete()
-
-
-class HookThread(PluginThread):
-    """thread for hooks"""
-
-    #----------------------------------------------------------------------
-    def __init__(self, m, function, args, kwargs):
-        """Constructor"""
-        PluginThread.__init__(self, m)
-
-        self.f = function
-        self.args = args
-        self.kwargs = kwargs
-
-        self.active = []
-
-        m.localThreads.append(self)
-
-        self.start()
-
-    def getActiveFiles(self):
-        return self.active
-
-    def addActive(self, pyfile):
-        """ Adds a pyfile to active list and thus will be displayed on overview"""
-        if pyfile not in self.active:
-            self.active.append(pyfile)
-
-    def finishFile(self, pyfile):
-        if pyfile in self.active:
-            self.active.remove(pyfile)
-
-        pyfile.finishIfDone()
-
-    def run(self):
-        try:
-            try:
-                self.kwargs["thread"] = self
-                self.f(*self.args, **self.kwargs)
-            except TypeError, e:
-                #dirty method to filter out exceptions
-                if "unexpected keyword argument 'thread'" not in e.args[0]:
-                    raise
-                
-                del self.kwargs["thread"]
-                self.f(*self.args, **self.kwargs)
-        finally:
-            local = copy(self.active)
-            for x in local:
-                self.finishFile(x)
-
-            self.m.localThreads.remove(self)
-
-
-class InfoThread(PluginThread):
-    def __init__(self, manager, data, pid=-1, rid=-1, add=False):
-        """Constructor"""
-        PluginThread.__init__(self, manager)
-
-        self.data = data
-        self.pid = pid # package id
-        # [ .. (name, plugin) .. ]
-
-        self.rid = rid #result id
-        self.add = add #add packages instead of return result
-
-        self.cache = [] #accumulated data
-
-        self.start()
-
-    def run(self):
-        """run method"""
-
-        plugins = {}
-        container = []
-
-        for url, plugin in self.data:
-            if plugin in plugins:
-                plugins[plugin].append(url)
-            else:
-                plugins[plugin] = [url]
-
-
-        # filter out container plugins
-        for name in self.m.core.pluginManager.containerPlugins:
-            if name in plugins:
-                container.extend([(name, url) for url in plugins[name]])
-
-                del plugins[name]
-
-        #directly write to database
-        if self.pid > -1:
-            for pluginname, urls in plugins.iteritems():
-                plugin = self.m.core.pluginManager.getPlugin(pluginname, True)
-                if hasattr(plugin, "getInfo"):
-                    self.fetchForPlugin(pluginname, plugin, urls, self.updateDB)
-                    self.m.core.files.save()
-
-        elif self.add:
-            for pluginname, urls in plugins.iteritems():
-                plugin = self.m.core.pluginManager.getPlugin(pluginname, True)
-                if hasattr(plugin, "getInfo"):
-                    self.fetchForPlugin(pluginname, plugin, urls, self.updateCache, True)
-
-                else:
-                    #generate default result
-                    result = [(url, 0, 3, url) for url in urls]
-
-                    self.updateCache(pluginname, result)
-
-            packs = parseNames([(name, url) for name, x, y, url in self.cache])
-
-            self.m.log.debug("Fetched and generated %d packages" % len(packs))
-
-            for k, v in packs:
-                self.m.core.api.addPackage(k, v)
-
-            #empty cache
-            del self.cache[:]
-
-        else: #post the results
-
-
-            for name, url in container:
-                #attach container content
-                try:
-                    data = self.decryptContainer(name, url)
-                except:
-                    print_exc()
-                    self.m.log.error("Could not decrypt container.")
-                    data = []
-
-                for url, plugin in data:
-                    if plugin in plugins:
-                        plugins[plugin].append(url)
-                    else:
-                        plugins[plugin] = [url]
-
-            self.m.infoResults[self.rid] = {}
-
-            for pluginname, urls in plugins.iteritems():
-                plugin = self.m.core.pluginManager.getPlugin(pluginname, True)
-                if hasattr(plugin, "getInfo"):
-                    self.fetchForPlugin(pluginname, plugin, urls, self.updateResult, True)
-
-                    #force to process cache
-                    if self.cache:
-                        self.updateResult(pluginname, [], True)
-
-                else:
-                    #generate default result
-                    result = [(url, 0, 3, url) for url in urls]
-
-                    self.updateResult(pluginname, result, True)
-
-            self.m.infoResults[self.rid]["ALL_INFO_FETCHED"] = {}
-
-        self.m.timestamp = time() + 5 * 60
-
-
-    def updateDB(self, plugin, result):
-        self.m.core.files.updateFileInfo(result, self.pid)
-
-    def updateResult(self, plugin, result, force=False):
-        #parse package name and generate result
-        #accumulate results
-
-        self.cache.extend(result)
-
-        if len(self.cache) >= 20 or force:
-            #used for package generating
-            tmp = [(name, (url, OnlineStatus(name, plugin, "unknown", status, int(size))))
-            for name, size, status, url in self.cache]
-
-            data = parseNames(tmp)
-            result = {}
-            for k, v in data.iteritems():
-                for url, status in v:
-                    status.packagename = k
-                    result[url] = status
-
-            self.m.setInfoResults(self.rid, result)
-
-            self.cache = []
-
-    def updateCache(self, plugin, result):
-        self.cache.extend(result)
-
-    def fetchForPlugin(self, pluginname, plugin, urls, cb, err=None):
-        try:
-            result = [] #result loaded from cache
-            process = [] #urls to process
-            for url in urls:
-                if url in self.m.infoCache:
-                    result.append(self.m.infoCache[url])
-                else:
-                    process.append(url)
-
-            if result:
-                self.m.log.debug("Fetched %d values from cache for %s" % (len(result), pluginname))
-                cb(pluginname, result)
-
-            if process:
-                self.m.log.debug("Run Info Fetching for %s" % pluginname)
-                for result in plugin.getInfo(process):
-                    #result = [ .. (name, size, status, url) .. ]
-                    if not type(result) == list: result = [result]
-
-                    for res in result:
-                        self.m.infoCache[res[3]] = res
-
-                    cb(pluginname, result)
-
-            self.m.log.debug("Finished Info Fetching for %s" % pluginname)
-        except Exception, e:
-            self.m.log.warning(_("Info Fetching for %(name)s failed | %(err)s") %
-                               {"name": pluginname, "err": str(e)})
-            if self.m.core.debug:
-                print_exc()
-
-            # generate default results
-            if err:
-                result = [(url, 0, 3, url) for url in urls]
-                cb(pluginname, result)
-
-
-    def decryptContainer(self, plugin, url):
-        data = []
-        # only works on container plugins
-
-        self.m.log.debug("Pre decrypting %s with %s" % (url, plugin))
-
-        # dummy pyfile
-        pyfile = PyFile(self.m.core.files, -1, url, url, 0, 0, "", plugin, -1, -1)
-
-        pyfile.initPlugin()
-
-        # little plugin lifecycle
-        try:
-            pyfile.plugin.setup()
-            pyfile.plugin.loadToDisk()
-            pyfile.plugin.decrypt(pyfile)
-            pyfile.plugin.deleteTmp()
-
-            for pack in pyfile.plugin.packages:
-                pyfile.plugin.urls.extend(pack[1])
-
-            data = self.m.core.pluginManager.parseUrls(pyfile.plugin.urls)
-
-            self.m.log.debug("Got %d links." % len(data))
-
-        except Exception, e:
-            self.m.log.debug("Pre decrypting error: %s" % str(e))
-        finally:
-            pyfile.release()
-
-        return data
diff --git a/module/PullEvents.py b/module/PullEvents.py
deleted file mode 100644
index 5ec76765e..000000000
--- a/module/PullEvents.py
+++ /dev/null
@@ -1,120 +0,0 @@
-# -*- coding: utf-8 -*-
-
-"""
-    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/>.
-    
-    @author: mkaay
-"""
-
-from time import time
-from module.utils import uniqify
-
-class PullManager():
-    def __init__(self, core):
-        self.core = core
-        self.clients = []
-    
-    def newClient(self, uuid):
-        self.clients.append(Client(uuid))
-    
-    def clean(self):
-        for n, client in enumerate(self.clients):
-            if client.lastActive + 30 < time():
-                del self.clients[n]
-    
-    def getEvents(self, uuid):
-        events = []
-        validUuid = False
-        for client in self.clients:
-            if client.uuid == uuid:
-                client.lastActive = time()
-                validUuid = True
-                while client.newEvents():
-                    events.append(client.popEvent().toList())
-                break
-        if not validUuid:
-            self.newClient(uuid)
-            events = [ReloadAllEvent("queue").toList(), ReloadAllEvent("collector").toList()]
-        return uniqify(events, repr)
-    
-    def addEvent(self, event):
-        for client in self.clients:
-            client.addEvent(event)
-
-class Client():
-    def __init__(self, uuid):
-        self.uuid = uuid
-        self.lastActive = time()
-        self.events = []
-    
-    def newEvents(self):
-        return len(self.events) > 0
-    
-    def popEvent(self):
-        if not len(self.events):
-            return None
-        return self.events.pop(0)
-    
-    def addEvent(self, event):
-        self.events.append(event)
-
-class UpdateEvent():
-    def __init__(self, itype, iid, destination):
-        assert itype == "pack" or itype == "file"
-        assert destination == "queue" or destination == "collector"
-        self.type = itype
-        self.id = iid
-        self.destination = destination
-    
-    def toList(self):
-        return ["update", self.destination, self.type, self.id]
-
-class RemoveEvent():
-    def __init__(self, itype, iid, destination):
-        assert itype == "pack" or itype == "file"
-        assert destination == "queue" or destination == "collector"
-        self.type = itype
-        self.id = iid
-        self.destination = destination
-    
-    def toList(self):
-        return ["remove", self.destination, self.type, self.id]
-
-class InsertEvent():
-    def __init__(self, itype, iid, after, destination):
-        assert itype == "pack" or itype == "file"
-        assert destination == "queue" or destination == "collector"
-        self.type = itype
-        self.id = iid
-        self.after = after
-        self.destination = destination
-    
-    def toList(self):
-        return ["insert", self.destination, self.type, self.id, self.after]
-
-class ReloadAllEvent():
-    def __init__(self, destination):
-        assert destination == "queue" or destination == "collector"
-        self.destination = destination
-        
-    def toList(self):
-        return ["reload", self.destination]
-
-class AccountUpdateEvent():
-    def toList(self):
-        return ["account"]
-
-class ConfigUpdateEvent():
-    def toList(self):
-        return ["config"]
diff --git a/module/PyFile.py b/module/PyFile.py
deleted file mode 100644
index 3dede9360..000000000
--- a/module/PyFile.py
+++ /dev/null
@@ -1,285 +0,0 @@
-#!/usr/bin/env python
-"""
-    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/>.
-
-    @author: RaNaN
-    @author: mkaay
-"""
-
-from module.PullEvents import UpdateEvent
-from module.utils import formatSize, lock
-
-from time import sleep, time
-
-from threading import RLock
-
-statusMap = {
-    "finished":    0,
-    "offline":     1,
-    "online":      2,
-    "queued":      3,
-    "skipped":     4,
-    "waiting":     5,
-    "temp. offline": 6,
-    "starting":    7,
-    "failed":      8,
-    "aborted":     9,
-    "decrypting":  10,
-    "custom":      11,
-    "downloading": 12,
-    "processing":  13,
-    "unknown":     14,
-}
-
-
-def setSize(self, value):
-    self._size = int(value)
-
-class PyFile(object):
-    """
-    Represents a file object at runtime
-    """
-    __slots__ = ("m", "id", "url", "name", "size", "_size", "status", "pluginname", "packageid",
-                 "error", "order", "lock", "plugin", "waitUntil", "active", "abort", "statusname",
-                 "reconnected", "progress", "maxprogress", "pluginmodule", "pluginclass")
-
-    def __init__(self, manager, id, url, name, size, status, error, pluginname, package, order):
-        self.m = manager
-        
-        self.id = int(id)
-        self.url = url
-        self.name = name
-        self.size = size
-        self.status = status
-        self.pluginname = pluginname
-        self.packageid = package #should not be used, use package() instead
-        self.error = error
-        self.order = order
-        # database information ends here
-
-        self.lock = RLock()
-        
-        self.plugin = None
-        #self.download = None
-            
-        self.waitUntil = 0 # time() + time to wait
-        
-        # status attributes
-        self.active = False #obsolete?
-        self.abort = False
-        self.reconnected = False
-
-        self.statusname = None
-        
-        self.progress = 0
-        self.maxprogress = 100
-
-        self.m.cache[int(id)] = self
-
-
-    # will convert all sizes to ints
-    size = property(lambda self: self._size, setSize)
-        
-    def __repr__(self):
-        return "PyFile %s: %s@%s" % (self.id, self.name, self.pluginname)
-
-    @lock
-    def initPlugin(self):
-        """ inits plugin instance """
-        if not self.plugin:
-            self.pluginmodule = self.m.core.pluginManager.getPlugin(self.pluginname)
-            self.pluginclass = getattr(self.pluginmodule, self.m.core.pluginManager.getPluginName(self.pluginname))
-            self.plugin = self.pluginclass(self)
-
-    @lock
-    def hasPlugin(self):
-        """Thread safe way to determine this file has initialized plugin attribute
-
-        :return:
-        """
-        return hasattr(self, "plugin") and self.plugin
-    
-    def package(self):
-        """ return package instance"""
-        return self.m.getPackage(self.packageid)
-
-    def setStatus(self, status):
-        self.status = statusMap[status]
-        self.sync() #@TODO needed aslong no better job approving exists
-
-    def setCustomStatus(self, msg, status="processing"):
-        self.statusname = msg
-        self.setStatus(status)
-
-    def getStatusName(self):
-        if self.status not in (13, 14) or not self.statusname:
-            return self.m.statusMsg[self.status]
-        else:
-            return self.statusname
-    
-    def hasStatus(self, status):
-        return statusMap[status] == self.status
-    
-    def sync(self):
-        """sync PyFile instance with database"""
-        self.m.updateLink(self)
-
-    @lock
-    def release(self):
-        """sync and remove from cache"""
-        # file has valid package
-        if self.packageid > 0:
-            self.sync()
-
-        if hasattr(self, "plugin") and self.plugin:
-            self.plugin.clean()
-            del self.plugin
-
-        self.m.releaseLink(self.id)
-
-    def delete(self):
-        """delete pyfile from database"""
-        self.m.deleteLink(self.id)
-
-    def toDict(self):
-        """return dict with all information for interface"""
-        return self.toDbDict()
-
-    def toDbDict(self):
-        """return data as dict for databse
-
-        format:
-
-        {
-            id: {'url': url, 'name': name ... }
-        }
-
-        """
-        return {
-            self.id: {
-                'id': self.id,
-                'url': self.url,
-                'name': self.name,
-                'plugin': self.pluginname,
-                'size': self.getSize(),
-                'format_size': self.formatSize(),
-                'status': self.status,
-                'statusmsg': self.getStatusName(),
-                'package': self.packageid,
-                'error': self.error,
-                'order': self.order
-            }
-        }
-
-    def abortDownload(self):
-        """abort pyfile if possible"""
-        while self.id in self.m.core.threadManager.processingIds():
-            self.abort = True
-            if self.plugin and self.plugin.req:
-                self.plugin.req.abortDownloads()
-            sleep(0.1)
-        
-        self.abort = False
-        if self.hasPlugin() and self.plugin.req:
-            self.plugin.req.abortDownloads()
-
-        self.release()
-        
-    def finishIfDone(self):
-        """set status to finish and release file if every thread is finished with it"""
-
-        if self.id in self.m.core.threadManager.processingIds():
-            return False
-        
-        self.setStatus("finished")
-        self.release()
-        self.m.checkAllLinksFinished()
-        return True
-
-    def checkIfProcessed(self):
-        self.m.checkAllLinksProcessed(self.id)
-    
-    def formatWait(self):
-        """ formats and return wait time in humanreadable format """
-        seconds = self.waitUntil - time()
-        
-        if seconds < 0: return "00:00:00"
-                
-        hours, seconds = divmod(seconds, 3600)
-        minutes, seconds = divmod(seconds, 60)
-        return "%.2i:%.2i:%.2i" % (hours, minutes, seconds)
-    
-    def formatSize(self):
-        """ formats size to readable format """
-        return formatSize(self.getSize())
-
-    def formatETA(self):
-        """ formats eta to readable format """
-        seconds = self.getETA()
-        
-        if seconds < 0: return "00:00:00"
-                
-        hours, seconds = divmod(seconds, 3600)
-        minutes, seconds = divmod(seconds, 60)
-        return "%.2i:%.2i:%.2i" % (hours, minutes, seconds)
-    
-    def getSpeed(self):
-        """ calculates speed """
-        try:
-            return self.plugin.req.speed
-        except:
-            return 0
-        
-    def getETA(self):
-        """ gets established time of arrival"""
-        try:
-            return self.getBytesLeft() / self.getSpeed()
-        except:
-            return 0
-    
-    def getBytesLeft(self):
-        """ gets bytes left """
-        try:
-            return self.plugin.req.size - self.plugin.req.arrived
-        except:
-            return 0
-    
-    def getPercent(self):
-        """ get % of download """
-        if self.status == 12:
-            try:
-                return self.plugin.req.percent
-            except:
-                return 0
-        else:
-            return self.progress
-        
-    def getSize(self):
-        """ get size of download """
-        try:
-            if self.plugin.req.size:
-                return self.plugin.req.size
-            else:
-                return self.size
-        except:
-            return self.size
-                
-    def notifyChange(self):
-        e = UpdateEvent("file", self.id, "collector" if not self.package().queue else "queue")
-        self.m.core.pullManager.addEvent(e)
-
-    def setProgress(self, value):
-        if not value == self.progress:
-            self.progress = value
-            self.notifyChange()
diff --git a/module/PyPackage.py b/module/PyPackage.py
deleted file mode 100644
index f3be6c886..000000000
--- a/module/PyPackage.py
+++ /dev/null
@@ -1,80 +0,0 @@
-#!/usr/bin/env python
-"""
-    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/>.
-
-    @author: RaNaN
-    @author: mkaay
-"""
-
-from module.PullEvents import UpdateEvent
-from module.utils import save_path
-
-class PyPackage():
-    """
-    Represents a package object at runtime
-    """
-    def __init__(self, manager, id, name, folder, site, password, queue, order):
-        self.m = manager
-        self.m.packageCache[int(id)] = self
-
-        self.id = int(id)
-        self.name = name
-        self._folder = folder
-        self.site = site
-        self.password = password
-        self.queue = queue
-        self.order = order
-        self.setFinished = False
-
-    @property
-    def folder(self):
-        return save_path(self._folder)
-
-    def toDict(self):
-        """ Returns a dictionary representation of the data.
-
-        :return: dict: {id: { attr: value }}
-        """
-        return {
-            self.id: {
-                'id': self.id,
-                'name': self.name,
-                'folder': self.folder,
-                'site': self.site,
-                'password': self.password,
-                'queue': self.queue,
-                'order': self.order,
-                'links': {}
-            }
-        }
-
-    def getChildren(self):
-        """get information about contained links"""
-        return self.m.getPackageData(self.id)["links"]
-
-    def sync(self):
-        """sync with db"""
-        self.m.updatePackage(self)
-
-    def release(self):
-        """sync and delete from cache"""
-        self.sync()
-        self.m.releasePackage(self.id)
-
-    def delete(self):
-        self.m.deletePackage(self.id)
-                
-    def notifyChange(self):
-        e = UpdateEvent("pack", self.id, "collector" if not self.queue else "queue")
-        self.m.core.pullManager.addEvent(e)
diff --git a/module/setup.py b/module/Setup.py
index 42b24859f..4e89ed0f2 100644
--- a/module/setup.py
+++ b/module/Setup.py
@@ -1,74 +1,88 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-"""
-    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/>.
-    
-    @author: RaNaN
-"""
-from getpass import getpass
+
+###############################################################################
+#   Copyright(c) 2008-2012 pyLoad Team
+#   http://www.pyload.org
+#
+#   This file is part of pyLoad.
+#   pyLoad is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU Affero General Public License as
+#   published by the Free Software Foundation, either version 3 of the
+#   License, or (at your option) any later version.
+#
+#   Subjected to the terms and conditions in LICENSE
+#
+#   @author: RaNaN
+###############################################################################
+
 import module.common.pylgettext as gettext
 import os
-from os import makedirs
-from os.path import abspath
-from os.path import dirname
-from os.path import exists
-from os.path import join
-from subprocess import PIPE
-from subprocess import call
 import sys
+import socket
+import webbrowser
+
+from getpass import getpass
+from time import time
 from sys import exit
+
+from module.utils.fs import abspath, dirname, exists, join, makedirs
 from module.utils import get_console_encoding
+from module.web.ServerThread import WebServer
+
 
 class Setup():
     """
-    pyLoads initial setup configuration assistent
+    pyLoads initial setup configuration assistant
     """
 
     def __init__(self, path, config):
         self.path = path
         self.config = config
         self.stdin_encoding = get_console_encoding(sys.stdin.encoding)
+        self.lang = None
+        # We will create a timestamp so that the setup will be completed in a specific interval
+        self.timestamp = time()
+
+        # TODO: probably unneeded
+        self.yes = "yes"
+        self.no = "no"
+
 
     def start(self):
-        langs = self.config.getMetaData("general", "language")["type"].split(";")
-        lang = self.ask(u"Choose your Language / Wähle deine Sprache", "en", langs)
-        gettext.setpaths([join(os.sep, "usr", "share", "pyload", "locale"), None])
-        translation = gettext.translation("setup", join(self.path, "locale"), languages=[lang, "en"], fallback=True)
-        translation.install(True)
+        web = WebServer(pysetup=self)
+        web.start()
 
-        #Input shorthand for yes
-        self.yes = _("y")
-        #Input shorthand for no
-        self.no = _("n")
+        error = web.check_error()
+        if error: #todo errno 44 port already in use
+            print error
+
+        url = "http://%s:%d/" % (socket.gethostbyname(socket.gethostname()), web.port)
+
+        print "Setup is started"
 
-        #        print ""
-        #        print _("Would you like to configure pyLoad via Webinterface?")
-        #        print _("You need a Browser and a connection to this PC for it.")
-        #        viaweb = self.ask(_("Start initial webinterface for configuration?"), "y", bool=True)
-        #        if viaweb:
-        #            try:
-        #                from module.web import ServerThread
-        #                ServerThread.setup = self
-        #                from module.web import webinterface
-        #                webinterface.run_simple()
-        #                return False
-        #            except Exception, e:
-        #                print "Setup failed with this error: ", e
-        #                print "Falling back to commandline setup."
+        opened = webbrowser.open_new_tab(url)
+        if not opened:
+            print "Please point your browser to %s" % url
 
 
+        self.ask_lang()
+
         print ""
+        print _("Would you like to configure pyLoad via Webinterface?")
+        print _("You need a Browser and a connection to this PC for it.")
+        print _("Url would be: http://hostname:8000/")
+        viaweb = self.ask(_("Start initial webinterface for configuration?"), self.yes, bool=True)
+        if viaweb:
+            self.start_web()
+        else:
+            self.start_cli()
+
+
+
+    def start_cli(self):
+
+
         print _("Welcome to the pyLoad Configuration Assistent.")
         print _("It will check your system and make a basic setup in order to run pyLoad.")
         print ""
@@ -82,39 +96,11 @@ class Setup():
         print _("When you are ready for system check, hit enter.")
         raw_input()
 
-        basic, ssl, captcha, gui, web, js = self.system_check()
-        print ""
-
-        if not basic:
-            print _("You need pycurl, sqlite and python 2.5, 2.6 or 2.7 to run pyLoad.")
-            print _("Please correct this and re-run pyLoad.")
-            print _("Setup will now close.")
-            raw_input()
-            return False
-
-        raw_input(_("System check finished, hit enter to see your status report."))
-        print ""
-        print _("## Status ##")
-        print ""
-
-        avail = []
-        if self.check_module("Crypto"): avail.append(_("container decrypting"))
-        if ssl: avail.append(_("ssl connection"))
-        if captcha: avail.append(_("automatic captcha decryption"))
-        if gui: avail.append(_("GUI"))
-        if web: avail.append(_("Webinterface"))
-        if js: avail.append(_("extended Click'N'Load"))
+        #self.get_page_next()
 
-        string = ""
-
-        for av in avail:
-            string += ", " + av
-
-        print _("Features available:") + string[1:]
-        print ""
 
         if len(avail) < 5:
-            print _("Featues missing: ")
+            print _("Features missing: ")
             print
 
             if not self.check_module("Crypto"):
@@ -125,7 +111,7 @@ class Setup():
             if not ssl:
                 print _("no SSL available")
                 print _("This is needed if you want to establish a secure connection to core or webinterface.")
-                print _("If you only want to access locally to pyLoad ssl is not usefull.")
+                print _("If you only want to access locally to pyLoad ssl is not useful.")
                 print ""
 
             if not captcha:
@@ -133,16 +119,11 @@ class Setup():
                 print _("Only needed for some hosters and as freeuser.")
                 print ""
 
-            if not gui:
-                print _("Gui not available")
-                print _("The Graphical User Interface.")
-                print ""
-
             if not js:
                 print _("no JavaScript engine found")
                 print _("You will need this for some Click'N'Load links. Install Spidermonkey, ossp-js, pyv8 or rhino")
 
-            print _("You can abort the setup now and fix some dependicies if you want.")
+            print _("You can abort the setup now and fix some dependencies if you want.")
 
         con = self.ask(_("Continue with setup?"), self.yes, bool=True)
 
@@ -152,7 +133,7 @@ class Setup():
         print ""
         print _("Do you want to change the config path? Current is %s") % abspath("")
         print _(
-            "If you use pyLoad on a server or the home partition lives on an iternal flash it may be a good idea to change it.")
+            "If you use pyLoad on a server or the home partition lives on an internal flash it may be a good idea to change it.")
         path = self.ask(_("Change config path?"), self.no, bool=True)
         if path:
             self.conf_path()
@@ -186,84 +167,23 @@ class Setup():
         raw_input()
         return True
 
-    def system_check(self):
-        """ make a systemcheck and return the results"""
-        print _("## System Check ##")
-
-        if sys.version_info[:2] > (2, 7):
-            print _("Your python version is to new, Please use Python 2.6/2.7")
-            python = False
-        elif sys.version_info[:2] < (2, 5):
-            print _("Your python version is to old, Please use at least Python 2.5")
-            python = False
-        else:
-            print _("Python Version: OK")
-            python = True
-
-        curl = self.check_module("pycurl")
-        self.print_dep("pycurl", curl)
-
-        sqlite = self.check_module("sqlite3")
-        self.print_dep("sqlite3", sqlite)
-
-        basic = python and curl and sqlite
 
+    def start_web(self):
         print ""
-
-        crypto = self.check_module("Crypto")
-        self.print_dep("pycrypto", crypto)
-
-        ssl = self.check_module("OpenSSL")
-        self.print_dep("py-OpenSSL", ssl)
-
-        print ""
-
-        pil = self.check_module("Image")
-        self.print_dep("py-imaging", pil)
-
-        if os.name == "nt":
-            tesser = self.check_prog([join(pypath, "tesseract", "tesseract.exe"), "-v"])
-        else:
-            tesser = self.check_prog(["tesseract", "-v"])
-
-        self.print_dep("tesseract", tesser)
-
-        captcha = pil and tesser
-
-        print ""
-
-        gui = self.check_module("PyQt4")
-        self.print_dep("PyQt4", gui)
-
-        print ""
-        jinja = True
-
+        print _("Webinterface running for setup.")
+        # TODO start browser?
         try:
-            import jinja2
-
-            v = jinja2.__version__
-            if v and "unknown" not in v:
-                if not v.startswith("2.5") and not v.startswith("2.6"):
-                    print _("Your installed jinja2 version %s seems too old.") % jinja2.__version__
-                    print _("You can safely continue but if the webinterface is not working,")
-                    print _("please upgrade or deinstall it, pyLoad includes a sufficient jinja2 libary.")
-                    print
-                    jinja = False
-        except:
-            pass
-
-        self.print_dep("jinja2", jinja)
-        beaker = self.check_module("beaker")
-        self.print_dep("beaker", beaker)
-
-        web = sqlite and beaker
-
-        from module.common import JsEngine
-
-        js = True if JsEngine.ENGINE else False
-        self.print_dep(_("JS engine"), js)
+            from module.web import ServerThread
+            ServerThread.setup = self
+            from module.web import webinterface
+            webinterface.run_simple()
+            self.web = True
+            return True
+        except Exception, e:
+            print "Webinterface failed with this error: ", e
+            print "Falling back to commandline setup."
+            self.start_cli()
 
-        return basic, ssl, captcha, gui, web, js
 
     def conf_basic(self):
         print ""
@@ -288,7 +208,7 @@ class Setup():
 
         print ""
         langs = self.config.getMetaData("general", "language")
-        self.config["general"]["language"] = self.ask(_("Language"), "en", langs["type"].split(";"))
+        self.config["general"]["language"] = self.ask(_("Language"), "en", langs.type.split(";"))
 
         self.config["general"]["download_folder"] = self.ask(_("Downloadfolder"), "Downloads")
         self.config["download"]["max_downloads"] = self.ask(_("Max parallel downloads"), "3")
@@ -313,11 +233,10 @@ class Setup():
         self.config["webinterface"]["port"] = self.ask(_("Port"), "8000")
         print ""
         print _("pyLoad offers several server backends, now following a short explanation.")
-        print "builtin:", _("Default server, best choice if you dont know which one to choose.")
-        print "threaded:", _("This server offers SSL and is a good alternative to builtin.")
+        print "threaded:", _("Default server, this server offers SSL and is a good alternative to builtin.")
         print "fastcgi:", _(
             "Can be used by apache, lighttpd, requires you to configure them, which is not too easy job.")
-        print "lightweight:", _("Very fast alternative written in C, requires libev and linux knowlegde.")
+        print "lightweight:", _("Very fast alternative written in C, requires libev and linux knowledge.")
         print "\t", _("Get it from here: https://github.com/jonashaag/bjoern, compile it")
         print "\t", _("and copy bjoern.so to module/lib")
 
@@ -326,7 +245,7 @@ class Setup():
             "Attention: In some rare cases the builtin server is not working, if you notice problems with the webinterface")
         print _("come back here and change the builtin server to the threaded one here.")
 
-        self.config["webinterface"]["server"] = self.ask(_("Server"), "builtin",
+        self.config["webinterface"]["server"] = self.ask(_("Server"), "threaded",
             ["builtin", "threaded", "fastcgi", "lightweight"])
 
     def conf_ssl(self):
@@ -340,7 +259,6 @@ class Setup():
         print "openssl req -days 36500 -x509 -key ssl.key -in ssl.csr > ssl.crt "
         print ""
         print _("If you're done and everything went fine, you can activate ssl now.")
-
         self.config["ssl"]["activated"] = self.ask(_("Activate SSL?"), self.yes, bool=True)
 
     def set_user(self):
@@ -375,10 +293,10 @@ class Setup():
                     print ""
                     print _("Users")
                     print "-----"
-                    users = db.listUsers()
+                    users = db.getAllUserData()
                     noaction = False
-                    for user in users:
-                        print user
+                    for user in users.itervalues():
+                        print user.name
                     print "-----"
                     print ""
                 elif action == "3":
@@ -388,6 +306,7 @@ class Setup():
                         db.removeUser(username)
                         noaction = False
                 elif action == "4":
+                    db.syncSave()
                     break
         finally:
             if not noaction:
@@ -400,7 +319,7 @@ class Setup():
                 languages=[self.config["general"]["language"], "en"], fallback=True)
             translation.install(True)
 
-        print _("Setting new configpath, current configuration will not be transfered!")
+        print _("Setting new configpath, current configuration will not be transferred!")
         path = self.ask(_("Configpath"), abspath(""))
         try:
             path = join(pypath, path)
@@ -416,34 +335,24 @@ class Setup():
         except Exception, e:
             print _("Setting config path failed: %s") % str(e)
 
-    def print_dep(self, name, value):
-        """Print Status of dependency"""
-        if value:
-            print _("%s: OK") % name
-        else:
-            print _("%s: missing") % name
-
 
-    def check_module(self, module):
-        try:
-            __import__(module)
-            return True
-        except:
-            return False
+    def ask_lang(self):
+        langs = self.config.getMetaData("general", "language").type.split(";")
+        self.lang = self.ask(u"Choose your Language / Wähle deine Sprache", "en", langs)
+        gettext.setpaths([join(os.sep, "usr", "share", "pyload", "locale"), None])
+        translation = gettext.translation("setup", join(self.path, "locale"), languages=[self.lang, "en"], fallback=True)
+        translation.install(True)
 
-    def check_prog(self, command):
-        pipe = PIPE
-        try:
-            call(command, stdout=pipe, stderr=pipe)
-            return True
-        except:
-            return False
+        #l10n Input shorthand for yes
+        self.yes = _("y")
+        #l10n Input shorthand for no
+        self.no = _("n")
 
     def ask(self, qst, default, answers=[], bool=False, password=False):
-        """produce one line to asking for input"""
+        """ Generate dialog on command line """
+
         if answers:
             info = "("
-
             for i, answer in enumerate(answers):
                 info += (", " if i != 0 else "") + str((answer == default and "[%s]" % answer) or answer)
 
@@ -475,24 +384,19 @@ class Setup():
                     return p1
                 else:
                     print _("Passwords did not match.")
-                    
-        while True:
-            try:
-                input = raw_input(qst + " %s: " % info)
-            except KeyboardInterrupt:
-                print "\nSetup interrupted"
-                exit()
 
+        while True:
+            input = raw_input(qst + " %s: " % info)
             input = input.decode(self.stdin_encoding)
 
             if input.strip() == "":
                 input = default
 
             if bool:
-                # yes, true,t are inputs for booleans with value true
+                #l10n yes, true,t are inputs for booleans with value true
                 if input.lower().strip() in [self.yes, _("yes"), _("true"), _("t"), "yes"]:
                     return True
-                # no, false,f are inputs for booleans with value false
+                #l10n no, false,f are inputs for booleans with value false
                 elif input.lower().strip() in [self.no, _("no"), _("false"), _("f"), "no"]:
                     return False
                 else:
diff --git a/module/api/AccountApi.py b/module/api/AccountApi.py
new file mode 100644
index 000000000..396824a55
--- /dev/null
+++ b/module/api/AccountApi.py
@@ -0,0 +1,49 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from module.Api import Api, RequirePerm, Permission
+
+from ApiComponent import ApiComponent
+
+class AccountApi(ApiComponent):
+    """ All methods to control accounts """
+
+    @RequirePerm(Permission.Accounts)
+    def getAccounts(self, refresh):
+        """Get information about all entered accounts.
+
+        :param refresh: reload account info
+        :return: list of `AccountInfo`
+        """
+        accs = self.core.accountManager.getAllAccounts(refresh)
+        accounts = []
+        for plugin in accs.itervalues():
+            accounts.extend(plugin.values())
+
+        return accounts
+
+    @RequirePerm(Permission.All)
+    def getAccountTypes(self):
+        """All available account types.
+
+        :return: string list
+        """
+        return self.core.pluginManager.getPlugins("accounts").keys()
+
+    @RequirePerm(Permission.Accounts)
+    def updateAccount(self, plugin, account, password=None, options={}):
+        """Changes pw/options for specific account."""
+        self.core.accountManager.updateAccount(plugin, account, password, options)
+
+    @RequirePerm(Permission.Accounts)
+    def removeAccount(self, plugin, account):
+        """Remove account from pyload.
+
+        :param plugin: pluginname
+        :param account: accountname
+        """
+        self.core.accountManager.removeAccount(plugin, account)
+
+
+if Api.extend(AccountApi):
+    del AccountApi
\ No newline at end of file
diff --git a/module/api/AddonApi.py b/module/api/AddonApi.py
new file mode 100644
index 000000000..917c7dc4c
--- /dev/null
+++ b/module/api/AddonApi.py
@@ -0,0 +1,27 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from module.Api import Api, RequirePerm, Permission
+
+from ApiComponent import ApiComponent
+
+class AddonApi(ApiComponent):
+    """ Methods to interact with addons """
+
+    def getAllInfo(self):
+        """Returns all information stored by addon plugins. Values are always strings
+
+        :return: {"plugin": {"name": value } }
+        """
+        return self.core.addonManager.getAllInfo()
+
+    def getInfoByPlugin(self, plugin):
+        """Returns information stored by a specific plugin.
+
+        :param plugin: pluginname
+        :return: dict of attr names mapped to value {"name": value}
+        """
+        return self.core.addonManager.getInfo(plugin)
+
+if Api.extend(AddonApi):
+    del AddonApi
\ No newline at end of file
diff --git a/module/api/ApiComponent.py b/module/api/ApiComponent.py
new file mode 100644
index 000000000..3948086c2
--- /dev/null
+++ b/module/api/ApiComponent.py
@@ -0,0 +1,23 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from module.remote.apitypes import Iface
+
+# Workaround to let code-completion think, this is subclass of Iface
+Iface = object
+class ApiComponent(Iface):
+
+    __slots__ = []
+
+    def __init__(self, core, user):
+        # Only for auto completion, this class can not be instantiated
+        from pyload import Core
+        from module.datatypes.User import User
+        assert isinstance(core, Core)
+        assert issubclass(ApiComponent, Iface)
+        self.core = core
+        assert isinstance(user, User)
+        self.user = user
+        self.primaryUID = 0
+        # No instantiating!
+        raise Exception()
\ No newline at end of file
diff --git a/module/api/CollectorApi.py b/module/api/CollectorApi.py
new file mode 100644
index 000000000..eb36f7a21
--- /dev/null
+++ b/module/api/CollectorApi.py
@@ -0,0 +1,37 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from module.Api import Api, RequirePerm, Permission
+
+from ApiComponent import ApiComponent
+
+class CollectorApi(ApiComponent):
+    """ Link collector """
+
+    @RequirePerm(Permission.All)
+    def getCollector(self):
+        pass
+
+    @RequirePerm(Permission.Add)
+    def addToCollector(self, links):
+        pass
+
+    @RequirePerm(Permission.Add)
+    def addFromCollector(self, name, new_name):
+        pass
+
+    @RequirePerm(Permission.Delete)
+    def deleteCollPack(self, name):
+        pass
+
+    @RequirePerm(Permission.Add)
+    def renameCollPack(self, name, new_name):
+        pass
+
+    @RequirePerm(Permission.Delete)
+    def deleteCollLink(self, url):
+        pass
+
+
+if Api.extend(CollectorApi):
+    del CollectorApi
\ No newline at end of file
diff --git a/module/api/ConfigApi.py b/module/api/ConfigApi.py
new file mode 100644
index 000000000..9df9455a2
--- /dev/null
+++ b/module/api/ConfigApi.py
@@ -0,0 +1,118 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from module.Api import Api, RequirePerm, Permission, ConfigHolder, ConfigItem, ConfigInfo
+from module.utils import to_string
+
+from ApiComponent import ApiComponent
+
+class ConfigApi(ApiComponent):
+    """ Everything related to configuration """
+
+    def getConfigValue(self, section, option):
+        """Retrieve config value.
+
+        :param section: name of category, or plugin
+        :param option: config option
+        :rtype: str
+        :return: config value as string
+        """
+        value = self.core.config.get(section, option, self.user)
+        return to_string(value)
+
+    def setConfigValue(self, section, option, value):
+        """Set new config value.
+
+        :param section:
+        :param option:
+        :param value: new config value
+        """
+        if option in ("limit_speed", "max_speed"): #not so nice to update the limit
+            self.core.requestFactory.updateBucket()
+
+        self.core.config.set(section, option, value, self.user)
+
+    def getConfig(self):
+        """Retrieves complete config of core.
+
+        :rtype: dict of section -> ConfigHolder
+        """
+        data = {}
+        for section, config, values in self.core.config.iterCoreSections():
+            holder = ConfigHolder(section, config.name, config.description, config.long_desc)
+            holder.items = [ConfigItem(option, x.name, x.description, x.type, to_string(x.default),
+                to_string(values.get(option, x.default))) for option, x in config.config.iteritems()]
+
+            data[section] = holder
+        return data
+
+    def getCoreConfig(self):
+        """ Retrieves core config sections
+
+        :rtype: list of PluginInfo
+        """
+        return [ConfigInfo(section, config.name, config.description, False, False)
+                for section, config, values in self.core.config.iterCoreSections()]
+
+    @RequirePerm(Permission.Plugins)
+    def getPluginConfig(self):
+        """All plugins and addons the current user has configured
+
+        :rtype: list of PluginInfo
+        """
+        # TODO: include addons that are activated by default
+        data = []
+        for name, config, values in self.core.config.iterSections(self.user):
+            if not values: continue
+            item = ConfigInfo(name, config.name, config.description,
+                self.core.pluginManager.getCategory(name),
+                self.core.pluginManager.isUserPlugin(name),
+                values.get("activated", False))
+            data.append(item)
+
+        return data
+
+    @RequirePerm(Permission.Plugins)
+    def getAvailablePlugins(self):
+        """List of all available plugins, that are configurable
+
+        :rtype: list of PluginInfo
+        """
+        # TODO: filter user_context / addons when not allowed
+        return [ConfigInfo(name, config.name, config.description,
+            self.core.pluginManager.getCategory(name),
+            self.core.pluginManager.isUserPlugin(name))
+                for name, config, values in self.core.config.iterSections(self.user)]
+
+    @RequirePerm(Permission.Plugins)
+    def configurePlugin(self, plugin):
+        """Get complete config options for desired section
+
+        :param plugin: Name of plugin or config section
+        :rtype: ConfigHolder
+        """
+
+        pass
+
+    @RequirePerm(Permission.Plugins)
+    def saveConfig(self, config):
+        """Used to save a configuration, core config can only be saved by admins
+
+        :param config: :class:`ConfigHolder`
+        """
+        pass
+
+    @RequirePerm(Permission.Plugins)
+    def deleteConfig(self, plugin):
+        """Deletes modified config
+
+        :param plugin: plugin name
+        """
+        self.core.config.delete(plugin, self.user)
+
+    @RequirePerm(Permission.Plugins)
+    def setConfigHandler(self, plugin, iid, value):
+        pass
+
+if Api.extend(ConfigApi):
+    del ConfigApi
\ No newline at end of file
diff --git a/module/api/CoreApi.py b/module/api/CoreApi.py
new file mode 100644
index 000000000..e5c5e8b41
--- /dev/null
+++ b/module/api/CoreApi.py
@@ -0,0 +1,131 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from module.Api import Api, RequirePerm, Permission, ServerStatus, Interaction
+from module.utils.fs import join, free_space
+from module.utils import compare_time
+
+from ApiComponent import ApiComponent
+
+class CoreApi(ApiComponent):
+    """ This module provides methods for general interaction with the core, like status or progress retrieval  """
+
+    @RequirePerm(Permission.All)
+    def getServerVersion(self):
+        """pyLoad Core version """
+        return self.core.version
+
+    @RequirePerm(Permission.All)
+    def getWSAddress(self):
+        """Gets and address for the websocket based on configuration"""
+        # TODO SSL (wss)
+        return "ws://%%s:%d" % self.core.config['remote']['port']
+
+    @RequirePerm(Permission.All)
+    def getServerStatus(self):
+        """Some general information about the current status of pyLoad.
+
+        :return: `ServerStatus`
+        """
+        queue = self.core.files.getQueueStats(self.primaryUID)
+        total = self.core.files.getDownloadStats(self.primaryUID)
+
+        serverStatus = ServerStatus(0,
+                                    total[0], queue[0],
+                                    total[1], queue[1],
+                                    self.isInteractionWaiting(Interaction.All),
+                                    not self.core.threadManager.pause and self.isTimeDownload(),
+                                    self.core.threadManager.pause,
+                                    self.core.config['reconnect']['activated'] and self.isTimeReconnect())
+
+
+        for pyfile in self.core.threadManager.getActiveDownloads(self.primaryUID):
+            serverStatus.speed += pyfile.getSpeed() #bytes/s
+
+        return serverStatus
+
+    @RequirePerm(Permission.All)
+    def getProgressInfo(self):
+        """ Status of all currently running tasks
+
+        :rtype: list of :class:`ProgressInfo`
+        """
+        return self.core.threadManager.getProgressList(self.primaryUID)
+
+    def pauseServer(self):
+        """Pause server: It won't start any new downloads, but nothing gets aborted."""
+        self.core.threadManager.pause = True
+
+    def unpauseServer(self):
+        """Unpause server: New Downloads will be started."""
+        self.core.threadManager.pause = False
+
+    def togglePause(self):
+        """Toggle pause state.
+
+        :return: new pause state
+        """
+        self.core.threadManager.pause ^= True
+        return self.core.threadManager.pause
+
+    def toggleReconnect(self):
+        """Toggle reconnect activation.
+
+        :return: new reconnect state
+        """
+        self.core.config["reconnect"]["activated"] ^= True
+        return self.core.config["reconnect"]["activated"]
+
+    def freeSpace(self):
+        """Available free space at download directory in bytes"""
+        return free_space(self.core.config["general"]["download_folder"])
+
+
+    def quit(self):
+        """Clean way to quit pyLoad"""
+        self.core.do_kill = True
+
+    def restart(self):
+        """Restart pyload core"""
+        self.core.do_restart = True
+
+    def getLog(self, offset=0):
+        """Returns most recent log entries.
+
+        :param offset: line offset
+        :return: List of log entries
+        """
+        filename = join(self.core.config['log']['log_folder'], 'log.txt')
+        try:
+            fh = open(filename, "r")
+            lines = fh.readlines()
+            fh.close()
+            if offset >= len(lines):
+                return []
+            return lines[offset:]
+        except:
+            return ['No log available']
+
+    @RequirePerm(Permission.All)
+    def isTimeDownload(self):
+        """Checks if pyload will start new downloads according to time in config.
+
+        :return: bool
+        """
+        start = self.core.config['downloadTime']['start'].split(":")
+        end = self.core.config['downloadTime']['end'].split(":")
+        return compare_time(start, end)
+
+    @RequirePerm(Permission.All)
+    def isTimeReconnect(self):
+        """Checks if pyload will try to make a reconnect
+
+        :return: bool
+        """
+        start = self.core.config['reconnect']['startTime'].split(":")
+        end = self.core.config['reconnect']['endTime'].split(":")
+        return compare_time(start, end) and self.core.config["reconnect"]["activated"]
+
+
+if Api.extend(CoreApi):
+    del CoreApi
\ No newline at end of file
diff --git a/module/api/DownloadApi.py b/module/api/DownloadApi.py
new file mode 100644
index 000000000..ba49435b3
--- /dev/null
+++ b/module/api/DownloadApi.py
@@ -0,0 +1,182 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from os.path import isabs
+
+from module.Api import Api, RequirePerm, Permission
+from module.utils.fs import join
+
+from ApiComponent import ApiComponent
+
+class DownloadApi(ApiComponent):
+    """ Component to create, add, delete or modify downloads."""
+
+    @RequirePerm(Permission.Add)
+    def generateAndAddPackages(self, links, paused=False):
+        """Generates and add packages
+
+        :param links: list of urls
+        :param paused: paused package
+        :return: list of package ids
+        """
+        return [self.addPackageP(name, urls, "", paused) for name, urls
+                in self.generatePackages(links).iteritems()]
+
+    @RequirePerm(Permission.Add)
+    def createPackage(self, name, folder, root, password="", site="", comment="", paused=False):
+        """Create a new package.
+
+        :param name: display name of the package
+        :param folder: folder name or relative path, abs path are not allowed
+        :param root: package id of root package, -1 for top level package
+        :param password: single pw or list of passwords separated with new line
+        :param site: arbitrary url to site for more information
+        :param comment: arbitrary comment
+        :param paused: No downloads will be started when True
+        :return: pid of newly created package
+        """
+
+        if isabs(folder):
+            folder = folder.replace("/", "_")
+
+        folder = folder.replace("http://", "").replace(":", "").replace("\\", "_").replace("..", "")
+
+        self.core.log.info(_("Added package %(name)s as folder %(folder)s") % {"name": name, "folder": folder})
+        pid = self.core.files.addPackage(name, folder, root, password, site, comment, paused)
+
+        return pid
+
+
+    @RequirePerm(Permission.Add)
+    def addPackage(self, name, links, password=""):
+        """Convenient method to add a package to the top-level and for adding links.
+
+        :return: package id
+        """
+        return self.addPackageChild(name, links, password, -1, False)
+
+    @RequirePerm(Permission.Add)
+    def addPackageP(self, name, links, password, paused):
+        """ Same as above with additional paused attribute. """
+        return self.addPackageChild(name, links, password, -1, paused)
+
+    @RequirePerm(Permission.Add)
+    def addPackageChild(self, name, links, password, root, paused):
+        """Adds a package, with links to desired package.
+
+        :param root: parents package id
+        :return: package id of the new package
+        """
+        if self.core.config['general']['folder_per_package']:
+            folder = name
+        else:
+            folder = ""
+
+        pid = self.createPackage(name, folder, root, password)
+        self.addLinks(pid, links)
+
+        return pid
+
+    @RequirePerm(Permission.Add)
+    def addLinks(self, pid, links):
+        """Adds links to specific package. Initiates online status fetching.
+
+        :param pid: package id
+        :param links: list of urls
+        """
+        hoster, crypter = self.core.pluginManager.parseUrls(links)
+
+        if hoster:
+            self.core.files.addLinks(hoster, pid)
+            self.core.threadManager.createInfoThread(hoster, pid)
+
+        self.core.threadManager.createDecryptThread(crypter, pid)
+
+        self.core.log.info((_("Added %d links to package") + " #%d" % pid) % len(hoster))
+        self.core.files.save()
+
+    @RequirePerm(Permission.Add)
+    def uploadContainer(self, filename, data):
+        """Uploads and adds a container file to pyLoad.
+
+        :param filename: filename, extension is important so it can correctly decrypted
+        :param data: file content
+        """
+        th = open(join(self.core.config["general"]["download_folder"], "tmp_" + filename), "wb")
+        th.write(str(data))
+        th.close()
+
+        return self.addPackage(th.name, [th.name])
+
+    @RequirePerm(Permission.Delete)
+    def deleteFiles(self, fids):
+        """Deletes several file entries from pyload.
+
+        :param fids: list of file ids
+        """
+        for fid in fids:
+            self.core.files.deleteFile(fid)
+
+        self.core.files.save()
+
+    @RequirePerm(Permission.Delete)
+    def deletePackages(self, pids):
+        """Deletes packages and containing links.
+
+        :param pids: list of package ids
+        """
+        for pid in pids:
+            self.core.files.deletePackage(pid)
+
+        self.core.files.save()
+
+
+    @RequirePerm(Permission.Modify)
+    def restartPackage(self, pid):
+        """Restarts a package, resets every containing files.
+
+        :param pid: package id
+        """
+        self.core.files.restartPackage(pid)
+
+    @RequirePerm(Permission.Modify)
+    def restartFile(self, fid):
+        """Resets file status, so it will be downloaded again.
+
+        :param fid: file id
+        """
+        self.core.files.restartFile(fid)
+
+    @RequirePerm(Permission.Modify)
+    def recheckPackage(self, pid):
+        """Check online status of all files in a package, also a default action when package is added. """
+        self.core.files.reCheckPackage(pid)
+
+    @RequirePerm(Permission.Modify)
+    def restartFailed(self):
+        """Restarts all failed failes."""
+        self.core.files.restartFailed()
+
+    @RequirePerm(Permission.Modify)
+    def stopAllDownloads(self):
+        """Aborts all running downloads."""
+
+        pyfiles = self.core.files.cachedFiles()
+        for pyfile in pyfiles:
+            pyfile.abortDownload()
+
+    @RequirePerm(Permission.Modify)
+    def stopDownloads(self, fids):
+        """Aborts specific downloads.
+
+        :param fids: list of file ids
+        :return:
+        """
+        pyfiles = self.core.files.cachedFiles()
+        for pyfile in pyfiles:
+            if pyfile.id in fids:
+                pyfile.abortDownload()
+
+
+if Api.extend(DownloadApi):
+    del DownloadApi
\ No newline at end of file
diff --git a/module/api/DownloadPreparingApi.py b/module/api/DownloadPreparingApi.py
new file mode 100644
index 000000000..4fc5b1ff9
--- /dev/null
+++ b/module/api/DownloadPreparingApi.py
@@ -0,0 +1,121 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from itertools import chain
+
+from module.Api import Api, RequirePerm, Permission, OnlineCheck, LinkStatus, urlmatcher
+from module.utils.fs import join
+from module.network.RequestFactory import getURL
+from module.common.packagetools import parseNames
+
+from ApiComponent import ApiComponent
+
+class DownloadPreparingApi(ApiComponent):
+    """ All kind of methods to parse links or retrieve online status """
+
+    @RequirePerm(Permission.Add)
+    def parseURLs(self, html=None, url=None):
+        """Parses html content or any arbitrary text for links and returns result of `checkURLs`
+
+        :param html: html source
+        :return:
+        """
+        urls = []
+
+        if html:
+            urls += [x[0] for x in urlmatcher.findall(html)]
+
+        if url:
+            page = getURL(url)
+            urls += [x[0] for x in urlmatcher.findall(page)]
+
+        # remove duplicates
+        return self.checkURLs(set(urls))
+
+
+    @RequirePerm(Permission.Add)
+    def checkURLs(self, urls):
+        """ Gets urls and returns pluginname mapped to list of matching urls.
+
+        :param urls:
+        :return: {plugin: urls}
+        """
+        data, crypter = self.core.pluginManager.parseUrls(urls)
+        plugins = {}
+
+        for url, plugin in chain(data, crypter):
+            if plugin in plugins:
+                plugins[plugin].append(url)
+            else:
+                plugins[plugin] = [url]
+
+        return plugins
+
+    @RequirePerm(Permission.Add)
+    def checkOnlineStatus(self, urls):
+        """ initiates online status check, will also decrypt files.
+
+        :param urls:
+        :return: initial set of data as :class:`OnlineCheck` instance containing the result id
+        """
+        data, crypter = self.core.pluginManager.parseUrls(urls)
+
+        # initial result does not contain the crypter links
+        tmp = [(url, (url, LinkStatus(url, pluginname, "unknown", 3, 0))) for url, pluginname in data]
+        data = parseNames(tmp)
+        result = {}
+
+        for k, v in data.iteritems():
+            for url, status in v:
+                status.packagename = k
+                result[url] = status
+
+        data.update(crypter) # hoster and crypter will be processed
+        rid = self.core.threadManager.createResultThread(data, False)
+
+        return OnlineCheck(rid, result)
+
+    @RequirePerm(Permission.Add)
+    def checkOnlineStatusContainer(self, urls, container, data):
+        """ checks online status of urls and a submitted container file
+
+        :param urls: list of urls
+        :param container: container file name
+        :param data: file content
+        :return: :class:`OnlineCheck`
+        """
+        th = open(join(self.core.config["general"]["download_folder"], "tmp_" + container), "wb")
+        th.write(str(data))
+        th.close()
+        urls.append(th.name)
+        return self.checkOnlineStatus(urls)
+
+    @RequirePerm(Permission.Add)
+    def pollResults(self, rid):
+        """ Polls the result available for ResultID
+
+        :param rid: `ResultID`
+        :return: `OnlineCheck`, if rid is -1 then there is no more data available
+        """
+        result = self.core.threadManager.getInfoResult(rid)
+
+        if "ALL_INFO_FETCHED" in result:
+            del result["ALL_INFO_FETCHED"]
+            return OnlineCheck(-1, result)
+        else:
+            return OnlineCheck(rid, result)
+
+
+    @RequirePerm(Permission.Add)
+    def generatePackages(self, links):
+        """ Parses links, generates packages names from urls
+
+        :param links: list of urls
+        :return: package names mapped to urls
+        """
+        result = parseNames((x, x) for x in links)
+        return result
+
+
+if Api.extend(DownloadPreparingApi):
+    del DownloadPreparingApi
\ No newline at end of file
diff --git a/module/api/FileApi.py b/module/api/FileApi.py
new file mode 100644
index 000000000..a5d5a8535
--- /dev/null
+++ b/module/api/FileApi.py
@@ -0,0 +1,161 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from module.Api import Api, RequirePerm, Permission, DownloadState, PackageDoesNotExists, FileDoesNotExists
+from module.utils import uniqify
+
+from ApiComponent import ApiComponent
+
+# TODO: user context
+class FileApi(ApiComponent):
+    """Everything related to available packages or files. Deleting, Modifying and so on."""
+
+    @RequirePerm(Permission.All)
+    def getAllFiles(self):
+        """ same as `getFileTree` for toplevel root and full tree"""
+        return self.getFileTree(-1, True)
+
+    @RequirePerm(Permission.All)
+    def getFilteredFiles(self, state):
+        """ same as `getFilteredFileTree` for toplevel root and full tree"""
+        return self.getFilteredFileTree(-1, state, True)
+
+    @RequirePerm(Permission.All)
+    def getFileTree(self, pid, full):
+        """ Retrieve data for specific package. full=True will retrieve all data available
+            and can result in greater delays.
+
+        :param pid: package id
+        :param full: go down the complete tree or only the first layer
+        :return: :class:`TreeCollection`
+        """
+        return self.core.files.getTree(pid, full, DownloadState.All)
+
+    @RequirePerm(Permission.All)
+    def getFilteredFileTree(self, pid, full, state):
+        """ Same as `getFileTree` but only contains files with specific download state.
+
+        :param pid: package id
+        :param full: go down the complete tree or only the first layer
+        :param state: :class:`DownloadState`, the attributes used for filtering
+        :return: :class:`TreeCollection`
+        """
+        return self.core.files.getTree(pid, full, state)
+
+    @RequirePerm(Permission.All)
+    def getPackageContent(self, pid):
+        """  Only retrieve content of a specific package. see `getFileTree`"""
+        return self.getFileTree(pid, False)
+
+    @RequirePerm(Permission.All)
+    def getPackageInfo(self, pid):
+        """Returns information about package, without detailed information about containing files
+
+        :param pid: package id
+        :raises PackageDoesNotExists:
+        :return: :class:`PackageInfo`
+        """
+        info = self.core.files.getPackageInfo(pid)
+        if not info:
+            raise PackageDoesNotExists(pid)
+        return info
+
+    @RequirePerm(Permission.All)
+    def getFileInfo(self, fid):
+        """ Info for specific file
+
+        :param fid: file id
+        :raises FileDoesNotExists:
+        :return: :class:`FileInfo`
+
+        """
+        info = self.core.files.getFileInfo(fid)
+        if not info:
+            raise FileDoesNotExists(fid)
+        return info
+
+    @RequirePerm(Permission.All)
+    def findFiles(self, pattern):
+        return self.core.files.getTree(-1, True, DownloadState.All, pattern)
+
+    @RequirePerm(Permission.All)
+    def searchSuggestions(self, pattern):
+        names = self.core.db.getMatchingFilenames(pattern, self.primaryUID)
+        # TODO: stemming and reducing the names to provide better suggestions
+        return uniqify(names)
+
+    @RequirePerm(Permission.All)
+    def findPackages(self, tags):
+        pass
+
+    @RequirePerm(Permission.Modify)
+    def updatePackage(self, pack):
+        """Allows to modify several package attributes.
+
+        :param pid: package id
+        :param data: :class:`PackageInfo`
+        """
+        pid = pack.pid
+        p = self.core.files.getPackage(pid)
+        if not p: raise PackageDoesNotExists(pid)
+
+        #TODO: fix
+        for key, value in data.iteritems():
+            if key == "id": continue
+            setattr(p, key, value)
+
+        p.sync()
+        self.core.files.save()
+
+    @RequirePerm(Permission.Modify)
+    def setPackageFolder(self, pid, path):
+        pass
+
+    @RequirePerm(Permission.Modify)
+    def movePackage(self, pid, root):
+        """ Set a new root for specific package. This will also moves the files on disk\
+           and will only work when no file is currently downloading.
+
+        :param pid: package id
+        :param root: package id of new root
+        :raises PackageDoesNotExists: When pid or root is missing
+        :return: False if package can't be moved
+        """
+        return self.core.files.movePackage(pid, root)
+
+    @RequirePerm(Permission.Modify)
+    def moveFiles(self, fids, pid):
+        """Move multiple files to another package. This will move the files on disk and\
+        only work when files are not downloading. All files needs to be continuous ordered
+        in the current package.
+
+        :param fids: list of file ids
+        :param pid: destination package
+        :return: False if files can't be moved
+        """
+        return self.core.files.moveFiles(fids, pid)
+
+    @RequirePerm(Permission.Modify)
+    def orderPackage(self, pid, position):
+        """Set new position for a package.
+
+        :param pid: package id
+        :param position: new position, 0 for very beginning
+        """
+        self.core.files.orderPackage(pid, position)
+
+    @RequirePerm(Permission.Modify)
+    def orderFiles(self, fids, pid, position):
+        """ Set a new position for a bunch of files within a package.
+        All files have to be in the same package and must be **continuous**\
+        in the package. That means no gaps between them.
+
+        :param fids: list of file ids
+        :param pid: package id of parent package
+        :param position:  new position: 0 for very beginning
+        """
+        self.core.files.orderFiles(fids, pid, position)
+
+
+if Api.extend(FileApi):
+    del FileApi
\ No newline at end of file
diff --git a/module/api/UserInteractionApi.py b/module/api/UserInteractionApi.py
new file mode 100644
index 000000000..b95b7c468
--- /dev/null
+++ b/module/api/UserInteractionApi.py
@@ -0,0 +1,61 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from module.Api import Api, RequirePerm, Permission, Interaction
+
+from ApiComponent import ApiComponent
+
+class UserInteractionApi(ApiComponent):
+    """ Everything needed for user interaction """
+
+    @RequirePerm(Permission.Interaction)
+    def isInteractionWaiting(self, mode):
+        """ Check if task is waiting.
+
+        :param mode: binary or'ed output type
+        :return: boolean
+        """
+        return self.core.interactionManager.isTaskWaiting(self.primaryUID, mode)
+
+    @RequirePerm(Permission.Interaction)
+    def getInteractionTasks(self, mode):
+        """Retrieve task for specific mode.
+
+        :param mode: binary or'ed interaction types which should be retrieved
+        :rtype list of :class:`InteractionTask`
+        """
+        tasks = self.core.interactionManager.getTasks(self.primaryUID, mode)
+        # retrieved tasks count as seen
+        for t in tasks:
+            t.seen = True
+            if t.type == Interaction.Notification:
+                t.setWaiting(self.core.interactionManager.CLIENT_THRESHOLD)
+
+        return tasks
+
+    @RequirePerm(Permission.Interaction)
+    def setInteractionResult(self, iid, result):
+        """Set Result for a interaction task. It will be immediately removed from task queue afterwards
+
+        :param iid: interaction id
+        :param result: result as json string
+        """
+        task = self.core.interactionManager.getTaskByID(iid)
+        if task and self.primaryUID == task.owner:
+            task.setResult(result)
+
+    @RequirePerm(Permission.Interaction)
+    def getAddonHandler(self):
+        pass
+
+    @RequirePerm(Permission.Interaction)
+    def callAddonHandler(self, plugin, func, pid_or_fid):
+        pass
+
+    @RequirePerm(Permission.Download)
+    def generateDownloadLink(self, fid, timeout):
+        pass
+
+
+if Api.extend(UserInteractionApi):
+    del UserInteractionApi
\ No newline at end of file
diff --git a/module/api/__init__.py b/module/api/__init__.py
new file mode 100644
index 000000000..1348fd26f
--- /dev/null
+++ b/module/api/__init__.py
@@ -0,0 +1,8 @@
+__all__ = ["CoreApi", "ConfigApi", "DownloadApi", "DownloadPreparingApi", "FileApi",
+           "CollectorApi", "UserInteractionApi", "AccountApi", "AddonApi"]
+
+# Import all components
+# from .import *
+# Above does not work in py 2.5
+for name in __all__:
+    __import__(__name__ + "." + name)
\ No newline at end of file
diff --git a/module/cli/ManageFiles.py b/module/cli/ManageFiles.py
index 4d0377d9d..c133d9959 100644
--- a/module/cli/ManageFiles.py
+++ b/module/cli/ManageFiles.py
@@ -32,7 +32,7 @@ class ManageFiles(Handler):
     def init(self):
         self.target = Destination.Queue
         self.pos = 0    #position in queue
-        self.package = -1  #choosen package
+        self.package = -1  #chosen package
         self.mode = ""   # move/delete/restart
 
         self.cache = None
@@ -107,10 +107,10 @@ class ManageFiles(Handler):
             elif self.mode == "r":
                 println(line, _("What do you want to restart?"))
 
-            println(line + 1, "Enter single number, comma seperated numbers or ranges. eg. 1,2,3 or 1-3.")
+            println(line + 1, "Enter a single number, comma separated numbers or ranges. e.g.: 1,2,3 or 1-3.")
             line += 2
         else:
-            println(line, _("Choose what yout want to do or enter package number."))
+            println(line, _("Choose what you want to do, or enter package number."))
             println(line + 1, ("%s - %%s, %s - %%s, %s - %%s" % (mag("d"), mag("m"), mag("r"))) % (
             _("delete"), _("move"), _("restart")))
             line += 2
diff --git a/module/common/APIExerciser.py b/module/common/APIExerciser.py
deleted file mode 100644
index 96f5ce9cf..000000000
--- a/module/common/APIExerciser.py
+++ /dev/null
@@ -1,157 +0,0 @@
-# -*- coding: utf-8 -*-
-
-import string
-from threading import Thread
-from random import choice, random, sample, randint
-from time import time, sleep
-from math import floor
-import gc
-
-from traceback import print_exc, format_exc
-
-from module.remote.thriftbackend.ThriftClient import ThriftClient, Destination
-
-def createURLs():
-    """ create some urls, some may fail """
-    urls = []
-    for x in range(0, randint(20, 100)):
-        name = "DEBUG_API"
-        if randint(0, 5) == 5:
-            name = "" #this link will fail
-
-        urls.append(name + "".join(sample(string.ascii_letters, randint(10, 20))))
-
-    return urls
-
-AVOID = (0,3,8)
-
-idPool = 0
-sumCalled = 0
-
-
-def startApiExerciser(core, n):
-    for i in range(n):
-        APIExerciser(core).start()
-
-class APIExerciser(Thread):
-
-
-    def __init__(self, core, thrift=False, user=None, pw=None):
-        global idPool
-
-        Thread.__init__(self)
-        self.setDaemon(True)
-        self.core = core
-        self.count = 0 #number of methods
-        self.time = time()
-
-        if thrift:
-            self.api = ThriftClient(user=user, password=pw)
-        else:
-            self.api = core.api
-
-
-        self.id = idPool
-
-        idPool += 1
-
-        #self.start()
-
-    def run(self):
-
-        self.core.log.info("API Excerciser started %d" % self.id)
-
-        out = open("error.log", "ab")
-        #core errors are not logged of course
-        out.write("\n" + "Starting\n")
-        out.flush()
-
-        while True:
-            try:
-                self.testAPI()
-            except Exception:
-                self.core.log.error("Excerciser %d throw an execption" % self.id)
-                print_exc()
-                out.write(format_exc() + 2 * "\n")
-                out.flush()
-
-            if not self.count % 100:
-                self.core.log.info("Exerciser %d tested %d api calls" % (self.id, self.count))
-            if not self.count % 1000:
-                out.flush()
-
-            if not sumCalled % 1000: #not thread safe
-                self.core.log.info("Exercisers tested %d api calls" % sumCalled)
-                persec = sumCalled / (time() - self.time)
-                self.core.log.info("Approx. %.2f calls per second." % persec)
-                self.core.log.info("Approx. %.2f ms per call." % (1000 / persec))
-                self.core.log.info("Collected garbage: %d" % gc.collect())
-
-
-                #sleep(random() / 500)
-
-    def testAPI(self):
-        global sumCalled
-
-        m = ["statusDownloads", "statusServer", "addPackage", "getPackageData", "getFileData", "deleteFiles",
-             "deletePackages", "getQueue", "getCollector", "getQueueData", "getCollectorData", "isCaptchaWaiting",
-             "getCaptchaTask", "stopAllDownloads", "getAllInfo", "getServices" , "getAccounts", "getAllUserData"]
-
-        method = choice(m)
-        #print "Testing:", method
-
-        if hasattr(self, method):
-            res = getattr(self, method)()
-        else:
-            res = getattr(self.api, method)()
-
-        self.count += 1
-        sumCalled += 1
-
-        #print res
-
-    def addPackage(self):
-        name = "".join(sample(string.ascii_letters, 10))
-        urls = createURLs()
-
-        self.api.addPackage(name, urls, choice([Destination.Queue, Destination.Collector]))
-
-
-    def deleteFiles(self):
-        info = self.api.getQueueData()
-        if not info: return
-
-        pack = choice(info)
-        fids = pack.links
-
-        if len(fids):
-            fids = [f.fid for f in sample(fids, randint(1, max(len(fids) / 2, 1)))]
-            self.api.deleteFiles(fids)
-
-
-    def deletePackages(self):
-        info = choice([self.api.getQueue(), self.api.getCollector()])
-        if not info: return
-
-        pids = [p.pid for p in info]
-        if len(pids):
-            pids = sample(pids, randint(1,  max(floor(len(pids) / 2.5), 1)))
-            self.api.deletePackages(pids)
-
-    def getFileData(self):
-        info = self.api.getQueueData()
-        if info:
-            p = choice(info)
-            if p.links:
-                self.api.getFileData(choice(p.links).fid)
-
-    def getPackageData(self):
-        info = self.api.getQueue()
-        if info:
-            self.api.getPackageData(choice(info).pid)
-
-    def getAccounts(self):
-        self.api.getAccounts(False)
-
-    def getCaptchaTask(self):
-        self.api.getCaptchaTask(False)
\ No newline at end of file
diff --git a/module/common/JsEngine.py b/module/common/JsEngine.py
index 576be2a1b..ef7494d16 100644
--- a/module/common/JsEngine.py
+++ b/module/common/JsEngine.py
@@ -27,8 +27,10 @@ ENGINE = ""
 DEBUG = False
 JS = False
 PYV8 = False
+NODE = False
 RHINO = False
 
+# TODO: Refactor + clean up this class
 
 if not ENGINE:
     try:
@@ -54,6 +56,19 @@ if not ENGINE or DEBUG:
 
 if not ENGINE or DEBUG:
     try:
+        import subprocess
+        subprocess.Popen(["node", "-v"], bufsize=-1, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()
+        p = subprocess.Popen(["node", "-e", "console.log(23+19)"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        out, err = p.communicate()
+        #integrity check
+        if out.strip() == "42":
+            ENGINE = "node"
+        NODE = True
+    except:
+        pass
+
+if not ENGINE or DEBUG:
+    try:
         path = "" #path where to find rhino
 
         if exists("/usr/share/java/js.jar"):
@@ -86,6 +101,10 @@ class JsEngine():
     def __nonzero__(self):
         return False if not ENGINE else True
 
+    def set_debug(self, value):
+        global DEBUG
+        DEBUG = value
+
     def eval(self, script):
         if not self.init:
             if ENGINE == "pyv8" or (DEBUG and PYV8):
@@ -105,6 +124,8 @@ class JsEngine():
                 return self.eval_pyv8(script)
             elif ENGINE == "js":
                 return self.eval_js(script)
+            elif ENGINE == "node":
+                return self.eval_node(script)
             elif ENGINE == "rhino":
                 return self.eval_rhino(script)
         else:
@@ -117,6 +138,10 @@ class JsEngine():
                 res = self.eval_js(script)
                 print "JS:", res
                 results.append(res)
+            if NODE:
+                res = self.eval_node(script)
+                print "NODE:", res
+                results.append(res)
             if RHINO:
                 res = self.eval_rhino(script)
                 print "Rhino:", res
@@ -144,6 +169,13 @@ class JsEngine():
         res = out.strip()
         return res
 
+    def eval_node(self, script):
+        script = "console.log(eval(unescape('%s')))" % quote(script)
+        p = subprocess.Popen(["node", "-e", script], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, bufsize=-1)
+        out, err = p.communicate()
+        res = out.strip()
+        return res
+
     def eval_rhino(self, script):
         script = "print(eval(unescape('%s')))" % quote(script)
         p = subprocess.Popen(["java", "-cp", path, "org.mozilla.javascript.tools.shell.Main", "-e", script],
@@ -153,10 +185,11 @@ class JsEngine():
         return res.decode("utf8").encode("ISO-8859-1")
 
     def error(self):
-        return _("No js engine detected, please install either Spidermonkey, ossp-js, pyv8 or rhino")
+        return _("No js engine detected, please install either Spidermonkey, ossp-js, pyv8, nodejs or rhino")
 
 if __name__ == "__main__":
     js = JsEngine()
+    js.set_debug(True)
 
     test = u'"ü"+"ä"'
     js.eval(test)
\ No newline at end of file
diff --git a/module/common/__init__.py b/module/common/__init__.py
index de6d13128..e69de29bb 100644
--- a/module/common/__init__.py
+++ b/module/common/__init__.py
@@ -1,2 +0,0 @@
-__author__ = 'christian'
-  
\ No newline at end of file
diff --git a/module/common/packagetools.py b/module/common/packagetools.py
index 5bfbcba95..791a46d51 100644
--- a/module/common/packagetools.py
+++ b/module/common/packagetools.py
@@ -21,7 +21,7 @@ def parseNames(files):
     """ Generates packages names from name, data lists
 
     :param files: list of (name, data)
-    :return: packagenames mapt to data lists (eg. urls)
+    :return: packagenames mapped to data lists (eg. urls)
     """
     packs = {}
 
@@ -64,7 +64,7 @@ def parseNames(files):
         if len(split) > 1:
             name = split.pop(1)
 
-            #check if a already existing package may be ok for this file
+            #check if an already existing package may be ok for this file
         #        found = False
         #        for pack in packs:
         #            if pack in file:
diff --git a/module/config/ConfigManager.py b/module/config/ConfigManager.py
new file mode 100644
index 000000000..8d908abaf
--- /dev/null
+++ b/module/config/ConfigManager.py
@@ -0,0 +1,134 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from new_collections import OrderedDict
+
+from module.Api import InvalidConfigSection
+from module.common.json_layer import json
+from module.utils import from_string, primary_uid
+
+from ConfigParser import ConfigParser
+
+
+def convertKeyError(func):
+    """ converts KeyError into InvalidConfigSection """
+
+    def conv(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except KeyError:
+            raise InvalidConfigSection(args[1])
+
+    return conv
+
+
+class ConfigManager(ConfigParser):
+    """ Manages the core config and configs for addons and single user.
+        Has similar interface to ConfigParser. """
+
+    def __init__(self, core, parser):
+        # No __init__ call to super class is needed!
+
+        self.core = core
+        self.db = core.db
+        # The config parser, holding the core config
+        self.parser = parser
+
+        # similar to parser, separated meta data and values
+        self.config = OrderedDict()
+
+        # Value cache for multiple user configs
+        # Values are populated from db on first access
+        # Entries are saved as (user, section) keys
+        self.values = {}
+        # TODO: similar to a cache, could be deleted periodically
+
+    def save(self):
+        self.parser.save()
+
+    @convertKeyError
+    def get(self, section, option, user=None):
+        """get config value, core config only available for admins.
+        if user is not valid default value will be returned"""
+
+        # Core config loaded from parser, when no user is given or he is admin
+        if section in self.parser and (not user or(user and user.isAdmin())):
+            return self.parser.get(section, option)
+        else:
+            # We need the id and not the instance
+            # Will be None for admin user and so the same as internal access
+            user = primary_uid(user)
+            try:
+                # Check if this config exists
+                # Configs without meta data can not be loaded!
+                data = self.config[section].config[option]
+                self.loadValues(user, section)
+                return self.values[user, section][option]
+            except KeyError:
+                pass # Returns default value later
+
+        return self.config[section].config[option].default
+
+    def loadValues(self, user, section):
+        if (user, section) not in self.values:
+            conf = self.db.loadConfig(section, user)
+            try:
+                self.values[user, section] = json.loads(conf) if conf else {}
+            except ValueError: # Something did go wrong when parsing
+                self.values[user, section] = {}
+                self.core.print_exc()
+
+    @convertKeyError
+    def set(self, section, option, value, sync=True, user=None):
+        """ set config value  """
+
+        changed = False
+        if section in self.parser and (not user or (user and user.isAdmin())):
+            changed = self.parser.set(section, option, value, sync)
+        else:
+            # associated id
+            user = primary_uid(user)
+            data = self.config[section].config[option]
+            value = from_string(value, data.type)
+            old_value = self.get(section, option)
+
+            # Values will always be saved to db, sync is ignored
+            if value != old_value:
+                changed = True
+                self.values[user, section][option] = value
+                self.saveValues(user, section)
+
+        if changed: self.core.evm.dispatchEvent("config:changed", section, option, value)
+        return changed
+
+    def saveValues(self, user, section):
+        self.db.saveConfig(section, json.dumps(self.values[user, section]), user)
+
+    def delete(self, section, user=False):
+        """ Deletes values saved in db and cached values for given user, NOT meta data
+            Does not trigger an error when nothing was deleted. """
+        user = user.primary if user else None
+        if (user, section) in self.values:
+            del self.values[user, section]
+
+        self.db.deleteConfig(section, user)
+
+    def iterCoreSections(self):
+        return self.parser.iterSections()
+
+    def iterSections(self, user=None):
+        """ Yields: section, metadata, values """
+
+        user = primary_uid(user)
+        values = self.db.loadConfigsForUser(user)
+
+        # Every section needs to be json decoded
+        for section, data in values.items():
+            try:
+                values[section] = json.loads(data) if data else {}
+            except ValueError:
+                values[section] = {}
+                self.core.print_exc()
+
+        for name, config in self.config.iteritems():
+            yield name, config, values[name] if name in values else {}
diff --git a/module/config/ConfigParser.py b/module/config/ConfigParser.py
new file mode 100644
index 000000000..2f974b75e
--- /dev/null
+++ b/module/config/ConfigParser.py
@@ -0,0 +1,203 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import with_statement
+from time import sleep
+from os.path import exists
+from gettext import gettext
+from new_collections import namedtuple, OrderedDict
+
+from module.utils import from_string
+from module.utils.fs import chmod
+
+from default import make_config
+
+CONF_VERSION = 2
+SectionTuple = namedtuple("SectionTuple", "name description long_desc config")
+ConfigData = namedtuple("ConfigData", "name type description default")
+
+class ConfigParser:
+    """
+    Holds and manages the configuration + meta data for config read from file.
+    """
+
+    CONFIG = "pyload.conf"
+
+    def __init__(self, config=None):
+
+        if config: self.CONFIG = config
+
+        # Meta data information
+        self.config = OrderedDict()
+        # The actual config values
+        self.values = {}
+
+        self.checkVersion()
+
+        self.loadDefault()
+        self.parseValues(self.CONFIG)
+
+    def loadDefault(self):
+        make_config(self)
+
+    def checkVersion(self):
+        """Determines if config needs to be deleted"""
+        e = None
+        # workaround conflict, with GUI (which also accesses the config) so try read in 3 times
+        for i in range(0, 3):
+            try:
+                if exists(self.CONFIG):
+                    f = open(self.CONFIG, "rb")
+                    v = f.readline()
+                    f.close()
+                    v = v[v.find(":") + 1:].strip()
+
+                    if not v or int(v) < CONF_VERSION:
+                        f = open(self.CONFIG, "wb")
+                        f.write("version: " + str(CONF_VERSION))
+                        f.close()
+                        print "Old version of %s deleted" % self.CONFIG
+                else:
+                    f = open(self.CONFIG, "wb")
+                    f.write("version:" + str(CONF_VERSION))
+                    f.close()
+
+            except Exception, ex:
+                e = ex
+                sleep(0.3)
+        if e: raise e
+
+
+    def parseValues(self, filename):
+        """read config values from file"""
+        f = open(filename, "rb")
+        config = f.readlines()[1:]
+
+        # save the current section
+        section = ""
+
+        for line in config:
+            line = line.strip()
+
+            # comment line, different variants
+            if not line or line.startswith("#") or line.startswith("//") or line.startswith(";"): continue
+
+            if line.startswith("["):
+                section = line.replace("[", "").replace("]", "")
+
+                if section not in self.config:
+                    print "Unrecognized section", section
+                    section = ""
+
+            else:
+                name, non, value = line.rpartition("=")
+                name = name.strip()
+                value = value.strip()
+
+                if not section:
+                    print "Value without section", name
+                    continue
+
+                if name in self.config[section].config:
+                    self.set(section, name, value, sync=False)
+                else:
+                    print "Unrecognized option", section, name
+
+
+    def save(self):
+        """saves config to filename"""
+
+        configs = []
+        f = open(self.CONFIG, "wb")
+        configs.append(f)
+        chmod(self.CONFIG, 0600)
+        f.write("version: %i\n\n" % CONF_VERSION)
+
+        for section, data in self.config.iteritems():
+            f.write("[%s]\n" % section)
+
+            for option, data in data.config.iteritems():
+                value = self.get(section, option)
+                if type(value) == unicode: value = value.encode("utf8")
+                else: value = str(value)
+
+                f.write('%s = %s\n' % (option, value))
+
+            f.write("\n")
+
+        f.close()
+
+    def __getitem__(self, section):
+        """provides dictionary like access: c['section']['option']"""
+        return Section(self, section)
+
+    def __contains__(self, section):
+        """ checks if parser contains section """
+        return section in self.config
+
+    def get(self, section, option):
+        """get value or default"""
+        try:
+            return self.values[section][option]
+        except KeyError:
+            return self.config[section].config[option].default
+
+    def set(self, section, option, value, sync=True):
+        """set value"""
+
+        data = self.config[section].config[option]
+        value = from_string(value, data.type)
+        old_value = self.get(section, option)
+
+        # only save when different values
+        if value != old_value:
+            if section not in self.values: self.values[section] = {}
+            self.values[section][option] = value
+            if sync:
+                self.save()
+            return True
+
+        return False
+
+    def getMetaData(self, section, option):
+        """ get all config data for an option """
+        return self.config[section].config[option]
+
+    def iterSections(self):
+        """ Yields section, config info, values, for all sections """
+
+        for name, config in self.config.iteritems():
+            yield name, config, self.values[name] if name in self.values else {}
+
+    def addConfigSection(self, section, name, desc, long_desc, config):
+        """Adds a section to the config. `config` is a list of config tuples as used in plugin api defined as:
+        The order of the config elements is preserved with OrderedDict
+        """
+        d = OrderedDict()
+
+        for entry in config:
+            if len(entry) == 5:
+                conf_name, type, conf_desc, conf_verbose, default = entry
+            else: # config options without description
+                conf_name, type, conf_desc, default = entry
+                conf_verbose = ""
+
+            d[conf_name] = ConfigData(gettext(conf_desc), type, gettext(conf_verbose), from_string(default, type))
+
+        data = SectionTuple(gettext(name), gettext(desc), gettext(long_desc), d)
+        self.config[section] = data
+
+class Section:
+    """provides dictionary like access for configparser"""
+
+    def __init__(self, parser, section):
+        """Constructor"""
+        self.parser = parser
+        self.section = section
+
+    def __getitem__(self, item):
+        """getitem"""
+        return self.parser.get(self.section, item)
+
+    def __setitem__(self, item, value):
+        """setitem"""
+        self.parser.set(self.section, item, value)
diff --git a/module/config/__init__.py b/module/config/__init__.py
new file mode 100644
index 000000000..4b31e848b
--- /dev/null
+++ b/module/config/__init__.py
@@ -0,0 +1 @@
+__author__ = 'christian'
diff --git a/module/config/default.conf b/module/config/default.conf
deleted file mode 100644
index 335ca10fe..000000000
--- a/module/config/default.conf
+++ /dev/null
@@ -1,65 +0,0 @@
-version: 1

-

-remote - "Remote":

-	int port : "Port" = 7227

-	ip listenaddr : "Adress" = 0.0.0.0

-	bool nolocalauth : "No authentication on local connections" = True

-	bool activated : "Activated" = True

-ssl - "SSL":

-	bool activated : "Activated"= False

-	file cert : "SSL Certificate" = ssl.crt

-	file key : "SSL Key" = ssl.key

-webinterface - "Webinterface":

-	bool activated : "Activated" = True

-	builtin;threaded;fastcgi;lightweight server : "Server" = builtin

-	bool https : "Use HTTPS" = False

-	ip host : "IP" = 0.0.0.0

-	int port : "Port" = 8001

-	str template : "Template" = default

-    str prefix: "Path Prefix" =

-log - "Log":

-	bool file_log : "File Log" = True

-	folder log_folder : "Folder" = Logs

-	int log_count : "Count" = 5

-	int log_size : "Size in kb" = 100

-	bool log_rotate : "Log Rotate" = True

-general - "General":

-	en;de;fr;it;es;nl;sv;ru;pl;cs;sr;pt_BR language : "Language" = en

-	folder download_folder : "Download Folder" = Downloads

-	bool debug_mode : "Debug Mode" = False

-	bool checksum : "Use Checksum" = False

-	int min_free_space : "Min Free Space (MB)" = 200

-	bool folder_per_package : "Create folder for each package" = True

-	int renice : "CPU Priority" = 0

-download - "Download":

-    int chunks : "Max connections for one download" = 3

-    int max_downloads : "Max Parallel Downloads" = 3

-    int max_speed : "Max Download Speed in kb/s" = -1

-    bool limit_speed : "Limit Download Speed" = False

-    str interface : "Download interface to bind (ip or Name)" = None

-    bool ipv6 : "Allow IPv6" = False

-    bool skip_existing : "Skip already existing files" = False

-permission - "Permissions":

-    bool change_user : "Change user of running process" = False

-    str user : "Username" = user

-    str folder : "Folder Permission mode" = 0755

-    bool change_file : "Change file mode of downloads" = False

-    str file : "Filemode for Downloads" = 0644

-    bool change_group : "Change group of running process" = False

-    str group : "Groupname" = users

-    bool change_dl : "Change Group and User of Downloads" = False

-reconnect - "Reconnect":

-	bool activated : "Use Reconnect" = False

-	str method : "Method" = None

-	time startTime : "Start" = 0:00

-	time endTime : "End" = 0:00

-downloadTime - "Download Time":

-	time start : "Start" = 0:00

-	time end : "End" = 0:00

-proxy - "Proxy":

-	str address : "Address" = "localhost"

-	int port : "Port" = 7070

-	http;socks4;socks5 type : "Protocol" = http

-	str username : "Username" = None

-	password password : "Password" = None

-    bool proxy : "Use Proxy" = False

diff --git a/module/config/default.py b/module/config/default.py
new file mode 100644
index 000000000..dfa967284
--- /dev/null
+++ b/module/config/default.py
@@ -0,0 +1,106 @@
+# -*- coding: utf-8 -*-
+
+"""
+Configuration layout for default base config
+"""
+
+#TODO: write tooltips and descriptions
+#TODO: use apis config related classes
+
+def make_config(config):
+    # Check if gettext is installed
+    _ = lambda x: x
+
+    config.addConfigSection("remote", _("Remote"), _("Description"), _("Long description"),
+        [
+            ("activated", "bool", _("Activated"), _("Tooltip"), True),
+            ("port", "int", _("Port"), _("Tooltip"), 7227),
+            ("listenaddr", "ip", _("Adress"), _("Tooltip"), "0.0.0.0"),
+        ])
+
+    config.addConfigSection("log", _("Log"), _("Description"), _("Long description"),
+        [
+            ("log_size", "int", _("Size in kb"), _("Tooltip"), 100),
+            ("log_folder", "folder", _("Folder"), _("Tooltip"), "Logs"),
+            ("file_log", "bool", _("File Log"), _("Tooltip"), True),
+            ("log_count", "int", _("Count"), _("Tooltip"), 5),
+            ("log_rotate", "bool", _("Log Rotate"), _("Tooltip"), True),
+        ])
+
+    config.addConfigSection("permission", _("Permissions"), _("Description"), _("Long description"),
+        [
+            ("group", "str", _("Groupname"), _("Tooltip"), "users"),
+            ("change_dl", "bool", _("Change Group and User of Downloads"), _("Tooltip"), False),
+            ("change_file", "bool", _("Change file mode of downloads"), _("Tooltip"), False),
+            ("user", "str", _("Username"), _("Tooltip"), "user"),
+            ("file", "str", _("Filemode for Downloads"), _("Tooltip"), "0644"),
+            ("change_group", "bool", _("Change group of running process"), _("Tooltip"), False),
+            ("folder", "str", _("Folder Permission mode"), _("Tooltip"), "0755"),
+            ("change_user", "bool", _("Change user of running process"), _("Tooltip"), False),
+        ])
+
+    config.addConfigSection("general", _("General"), _("Description"), _("Long description"),
+        [
+            ("language", "en;de;fr;it;es;nl;sv;ru;pl;cs;sr;pt_BR", _("Language"), _("Tooltip"), "en"),
+            ("download_folder", "folder", _("Download Folder"), _("Tooltip"), "Downloads"),
+            ("checksum", "bool", _("Use Checksum"), _("Tooltip"), False),
+            ("folder_per_package", "bool", _("Create folder for each package"), _("Tooltip"), True),
+            ("debug_mode", "bool", _("Debug Mode"), _("Tooltip"), False),
+            ("min_free_space", "int", _("Min Free Space (MB)"), _("Tooltip"), 200),
+            ("renice", "int", _("CPU Priority"), _("Tooltip"), 0),
+        ])
+
+    config.addConfigSection("ssl", _("SSL"), _("Description"), _("Long description"),
+        [
+            ("cert", "file", _("SSL Certificate"), _("Tooltip"), "ssl.crt"),
+            ("activated", "bool", _("Activated"), _("Tooltip"), False),
+            ("key", "file", _("SSL Key"), _("Tooltip"), "ssl.key"),
+        ])
+
+    config.addConfigSection("webinterface", _("Webinterface"), _("Description"), _("Long description"),
+        [
+            ("template", "str", _("Template"), _("Tooltip"), "default"),
+            ("activated", "bool", _("Activated"), _("Tooltip"), True),
+            ("prefix", "str", _("Path Prefix"), _("Tooltip"), ""),
+            ("server", "auto;threaded;fallback;fastcgi", _("Server"), _("Tooltip"), "auto"),
+            ("force_server", "str", _("Favor specific server"), _("Tooltip"), ""),
+            ("host", "ip", _("IP"), _("Tooltip"), "0.0.0.0"),
+            ("https", "bool", _("Use HTTPS"), _("Tooltip"), False),
+            ("port", "int", _("Port"), _("Tooltip"), 8001),
+        ])
+
+    config.addConfigSection("proxy", _("Proxy"), _("Description"), _("Long description"),
+        [
+            ("username", "str", _("Username"), _("Tooltip"), ""),
+            ("proxy", "bool", _("Use Proxy"), _("Tooltip"), False),
+            ("address", "str", _("Address"), _("Tooltip"), "localhost"),
+            ("password", "password", _("Password"), _("Tooltip"), ""),
+            ("type", "http;socks4;socks5", _("Protocol"), _("Tooltip"), "http"),
+            ("port", "int", _("Port"), _("Tooltip"), 7070),
+        ])
+
+    config.addConfigSection("reconnect", _("Reconnect"), _("Description"), _("Long description"),
+        [
+            ("endTime", "time", _("End"), _("Tooltip"), "0:00"),
+            ("activated", "bool", _("Use Reconnect"), _("Tooltip"), False),
+            ("method", "str", _("Method"), _("Tooltip"), "./reconnect.sh"),
+            ("startTime", "time", _("Start"), _("Tooltip"), "0:00"),
+        ])
+
+    config.addConfigSection("download", _("Download"), _("Description"), _("Long description"),
+        [
+            ("max_downloads", "int", _("Max Parallel Downloads"), _("Tooltip"), 3),
+            ("limit_speed", "bool", _("Limit Download Speed"), _("Tooltip"), False),
+            ("interface", "str", _("Download interface to bind (ip or Name)"), _("Tooltip"), ""),
+            ("skip_existing", "bool", _("Skip already existing files"), _("Tooltip"), False),
+            ("max_speed", "int", _("Max Download Speed in kb/s"), _("Tooltip"), -1),
+            ("ipv6", "bool", _("Allow IPv6"), _("Tooltip"), False),
+            ("chunks", "int", _("Max connections for one download"), _("Tooltip"), 3),
+            ("restart_failed", "bool", _("Restart failed downloads on startup"), _("Tooltip"), False),
+        ])
+
+    config.addConfigSection("downloadTime", _("Download Time"), _("Description"), _("Long description"),
+        [
+            ("start", "time", _("Start"), _("Tooltip"), "0:00"),
+            ("end", "time", _("End"), _("Tooltip"), "0:00"),
+        ])
diff --git a/module/config/gui_default.xml b/module/config/gui_default.xml
deleted file mode 100644
index 1faed776f..000000000
--- a/module/config/gui_default.xml
+++ /dev/null
@@ -1,13 +0,0 @@
-<?xml version="1.0" ?>
-<root>
-    <connections>
-        <connection default="True" type="local" id="33965310e19b4a869112c43b39a16440">
-            <name>Local</name>
-        </connection>
-    </connections>
-    <mainWindow>
-        <state></state>
-        <geometry></geometry>
-    </mainWindow>
-    <language>en</language>
-</root>
diff --git a/module/database/AccountDatabase.py b/module/database/AccountDatabase.py
new file mode 100644
index 000000000..1602451fa
--- /dev/null
+++ b/module/database/AccountDatabase.py
@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+
+from module.database import queue, async
+from module.database import DatabaseBackend
+
+class AccountMethods:
+
+    @queue
+    def loadAccounts(db):
+        db.c.execute('SELECT plugin, loginname, activated, password, options FROM accounts;')
+        return db.c.fetchall()
+
+    @async
+    def saveAccounts(db, data):
+        db.c.executemany('INSERT INTO accounts(plugin, loginname, activated, password, options) VALUES(?,?,?,?,?)', data)
+
+    @async
+    def removeAccount(db, plugin, loginname):
+        db.c.execute('DELETE FROM accounts WHERE plugin=? AND loginname=?', (plugin, loginname))
+
+DatabaseBackend.registerSub(AccountMethods)
\ No newline at end of file
diff --git a/module/database/ConfigDatabase.py b/module/database/ConfigDatabase.py
new file mode 100644
index 000000000..2e9fdd9a0
--- /dev/null
+++ b/module/database/ConfigDatabase.py
@@ -0,0 +1,60 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from module.database import DatabaseMethods, queue, async
+
+class ConfigMethods(DatabaseMethods):
+
+    @async
+    def saveConfig(self, plugin, config, user=None):
+        if user is None:
+            self.c.execute('INSERT INTO settings(plugin, config) VALUES(?,?)', (plugin, config))
+        else:
+            self.c.execute('INSERT INTO settings(plugin, config, user) VALUES(?,?,?)', (plugin, config, user))
+
+
+    @queue
+    def loadConfig(self, plugin, user=None):
+        if user is None:
+            self.c.execute('SELECT config FROM settings WHERE plugin=? AND user=-1', (plugin, ))
+        else:
+            self.c.execute('SELECT config FROM settings WHERE plugin=? AND user=?', (plugin, user))
+
+        r = self.c.fetchone()
+        return r[0] if r else ""
+
+    @async
+    def deleteConfig(self, plugin, user=None):
+        if user is None:
+            self.c.execute('DELETE FROM settings WHERE plugin=?', (plugin, ))
+        else:
+            self.c.execute('DELETE FROM settings WHERE plugin=? AND user=?', (plugin, user))
+
+    @queue
+    def loadAllConfigs(self):
+        self.c.execute('SELECT user, plugin, config FROM settings')
+        configs = {}
+        for r in self.c:
+            if r[0] in configs:
+                configs[r[0]][r[1]] = r[2]
+            else:
+                configs[r[0]] = {r[1]: r[2]}
+
+        return configs
+
+    @queue
+    def loadConfigsForUser(self, user=None):
+        if user is None: user = -1
+        self.c.execute('SELECT plugin, config FROM settings WHERE user=?', (user,))
+        configs = {}
+        for r in self.c:
+            configs[r[0]] = r[1]
+
+        return configs
+
+    @async
+    def clearAllConfigs(self):
+        self.c.execute('DELETE FROM settings')
+
+
+ConfigMethods.register()
\ No newline at end of file
diff --git a/module/database/DatabaseBackend.py b/module/database/DatabaseBackend.py
index 9530390c3..e77fc0966 100644
--- a/module/database/DatabaseBackend.py
+++ b/module/database/DatabaseBackend.py
@@ -1,86 +1,98 @@
 #!/usr/bin/env python
-"""
-    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/>.
-
-    @author: RaNaN
-    @author: mkaay
-"""
-from threading import Thread
-from threading import Event
-from os import remove
-from os.path import exists
+# -*- coding: utf-8 -*-
+
+###############################################################################
+#   Copyright(c) 2008-2012 pyLoad Team
+#   http://www.pyload.org
+#
+#   This file is part of pyLoad.
+#   pyLoad is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU Affero General Public License as
+#   published by the Free Software Foundation, either version 3 of the
+#   License, or (at your option) any later version.
+#
+#   Subjected to the terms and conditions in LICENSE
+#
+#   @author: RaNaN, mkaay
+###############################################################################
+
+from threading import Thread, Event
 from shutil import move
 
 from Queue import Queue
 from traceback import print_exc
 
-from module.utils import chmod
+from module.utils.fs import chmod, exists, remove
 
 try:
     from pysqlite2 import dbapi2 as sqlite3
 except:
     import sqlite3
 
-DB_VERSION = 4
+DB = None
+DB_VERSION = 5
+
+def set_DB(db):
+    global DB
+    DB = db
+
+
+def queue(f):
+    @staticmethod
+    def x(*args, **kwargs):
+        if DB:
+            return DB.queue(f, *args, **kwargs)
+
+    return x
+
+
+def async(f):
+    @staticmethod
+    def x(*args, **kwargs):
+        if DB:
+            return DB.async(f, *args, **kwargs)
+
+    return x
+
+
+def inner(f):
+    @staticmethod
+    def x(*args, **kwargs):
+        if DB:
+            return f(DB, *args, **kwargs)
+
+    return x
+
+
+class DatabaseMethods:
+    # stubs for autocompletion
+    core = None
+    manager = None
+    conn = None
+    c = None
 
-class style():
-    db = None
-    
-    @classmethod
-    def setDB(cls, db):
-        cls.db = db
-    
-    @classmethod
-    def inner(cls, f):
-        @staticmethod
-        def x(*args, **kwargs):
-            if cls.db:
-                return f(cls.db, *args, **kwargs)
-        return x
-    
-    @classmethod
-    def queue(cls, f):
-        @staticmethod
-        def x(*args, **kwargs):
-            if cls.db:
-                return cls.db.queue(f, *args, **kwargs)
-        return x
-    
     @classmethod
-    def async(cls, f):
-        @staticmethod
-        def x(*args, **kwargs):
-            if cls.db:
-                return cls.db.async(f, *args, **kwargs)
-        return x
+    def register(cls):
+        DatabaseBackend.registerSub(cls)
+
 
 class DatabaseJob():
     def __init__(self, f, *args, **kwargs):
         self.done = Event()
-        
+
         self.f = f
         self.args = args
         self.kwargs = kwargs
-        
+
         self.result = None
         self.exception = False
 
-#        import inspect
-#        self.frame = inspect.currentframe()
+    #        import inspect
+    #        self.frame = inspect.currentframe()
 
     def __repr__(self):
         from os.path import basename
+
         frame = self.frame.f_back
         output = ""
         for i in range(5):
@@ -104,249 +116,377 @@ class DatabaseJob():
             self.exception = e
         finally:
             self.done.set()
-    
+
     def wait(self):
         self.done.wait()
 
+
 class DatabaseBackend(Thread):
     subs = []
+
+    DB_FILE = "pyload.db"
+    VERSION_FILE = "db.version"
+
     def __init__(self, core):
         Thread.__init__(self)
         self.setDaemon(True)
         self.core = core
+        self.manager = None # set later
+        self.running = Event()
 
         self.jobs = Queue()
-        
-        self.setuplock = Event()
-        
-        style.setDB(self)
-    
+
+        set_DB(self)
+
     def setup(self):
+        """ *MUST* be called before db can be used !"""
         self.start()
-        self.setuplock.wait()
-    
-    def run(self):
+        self.running.wait()
+
+    def init(self):
         """main loop, which executes commands"""
-        convert = self._checkVersion() #returns None or current version
-        
-        self.conn = sqlite3.connect("files.db")
-        chmod("files.db", 0600)
-
-        self.c = self.conn.cursor() #compatibility
-        
-        if convert is not None:
-            self._convertDB(convert)
-        
-        self._createTables()
-        self._migrateUser()
 
+        version = self._checkVersion()
+
+        self.conn = sqlite3.connect(self.DB_FILE)
+        chmod(self.DB_FILE, 0600)
+
+        self.c = self.conn.cursor()
+
+        if version is not None and version < DB_VERSION:
+            success = self._convertDB(version)
+
+            # delete database
+            if not success:
+                self.c.close()
+                self.conn.close()
+
+                try:
+                    self.manager.core.log.warning(_("File database was deleted due to incompatible version."))
+                except:
+                    print "File database was deleted due to incompatible version."
+
+                remove(self.VERSION_FILE)
+                move(self.DB_FILE, self.DB_FILE + ".backup")
+                f = open(self.VERSION_FILE, "wb")
+                f.write(str(DB_VERSION))
+                f.close()
+
+                self.conn = sqlite3.connect(self.DB_FILE)
+                chmod(self.DB_FILE, 0600)
+                self.c = self.conn.cursor()
+
+        self._createTables()
         self.conn.commit()
-        
-        self.setuplock.set()
-        
+
+
+    def run(self):
+        try:
+            self.init()
+        finally:
+            self.running.set()
+
         while True:
             j = self.jobs.get()
             if j == "quit":
                 self.c.close()
+                self.conn.commit()
                 self.conn.close()
+                self.closing.set()
                 break
             j.processJob()
 
-    @style.queue
+
     def shutdown(self):
-        self.conn.commit()
+        self.running.clear()
+        self.closing = Event()
         self.jobs.put("quit")
+        self.closing.wait(1)
 
     def _checkVersion(self):
-        """ check db version and delete it if needed"""
-        if not exists("files.version"):
-            f = open("files.version", "wb")
+        """ get db version"""
+        if not exists(self.VERSION_FILE):
+            f = open(self.VERSION_FILE, "wb")
             f.write(str(DB_VERSION))
             f.close()
             return
-        
-        f = open("files.version", "rb")
+
+        f = open(self.VERSION_FILE, "rb")
         v = int(f.read().strip())
         f.close()
-        if v < DB_VERSION:
-            if v < 2:
-                try:
-                    self.manager.core.log.warning(_("Filedatabase was deleted due to incompatible version."))
-                except:
-                    print "Filedatabase was deleted due to incompatible version."
-                remove("files.version")
-                move("files.db", "files.backup.db")
-            f = open("files.version", "wb")
-            f.write(str(DB_VERSION))
-            f.close()
-            return v
-    
+
+        return v
+
     def _convertDB(self, v):
         try:
-            getattr(self, "_convertV%i" % v)()
+            return getattr(self, "_convertV%i" % v)()
         except:
-            try:
-                self.core.log.error(_("Filedatabase could NOT be converted."))
-            except:
-                print "Filedatabase could NOT be converted."
-    
+            return False
+
     #--convert scripts start
-    
-    def _convertV2(self):
-        self.c.execute('CREATE TABLE IF NOT EXISTS "storage" ("id" INTEGER PRIMARY KEY AUTOINCREMENT, "identifier" TEXT NOT NULL, "key" TEXT NOT NULL, "value" TEXT DEFAULT "")')
-        try:
-            self.manager.core.log.info(_("Database was converted from v2 to v3."))
-        except:
-            print "Database was converted from v2 to v3."
-        self._convertV3()
-    
-    def _convertV3(self):
-        self.c.execute('CREATE TABLE IF NOT EXISTS "users" ("id" INTEGER PRIMARY KEY AUTOINCREMENT, "name" TEXT NOT NULL, "email" TEXT DEFAULT "" NOT NULL, "password" TEXT NOT NULL, "role" INTEGER DEFAULT 0 NOT NULL, "permission" INTEGER DEFAULT 0 NOT NULL, "template" TEXT DEFAULT "default" NOT NULL)')
-        try:
-            self.manager.core.log.info(_("Database was converted from v3 to v4."))
-        except:
-            print "Database was converted from v3 to v4."
-    
+
+    def _convertV5(self):
+        return False
+
     #--convert scripts end
-    
+
     def _createTables(self):
         """create tables for database"""
 
-        self.c.execute('CREATE TABLE IF NOT EXISTS "packages" ("id" INTEGER PRIMARY KEY AUTOINCREMENT, "name" TEXT NOT NULL, "folder" TEXT, "password" TEXT DEFAULT "", "site" TEXT DEFAULT "", "queue" INTEGER DEFAULT 0 NOT NULL, "packageorder" INTEGER DEFAULT 0 NOT NULL)')
-        self.c.execute('CREATE TABLE IF NOT EXISTS "links" ("id" INTEGER PRIMARY KEY AUTOINCREMENT, "url" TEXT NOT NULL, "name" TEXT, "size" INTEGER DEFAULT 0 NOT NULL, "status" INTEGER DEFAULT 3 NOT NULL, "plugin" TEXT DEFAULT "BasePlugin" NOT NULL, "error" TEXT DEFAULT "", "linkorder" INTEGER DEFAULT 0 NOT NULL, "package" INTEGER DEFAULT 0 NOT NULL, FOREIGN KEY(package) REFERENCES packages(id))')
-        self.c.execute('CREATE INDEX IF NOT EXISTS "pIdIndex" ON links(package)')
-        self.c.execute('CREATE TABLE IF NOT EXISTS "storage" ("id" INTEGER PRIMARY KEY AUTOINCREMENT, "identifier" TEXT NOT NULL, "key" TEXT NOT NULL, "value" TEXT DEFAULT "")')
-        self.c.execute('CREATE TABLE IF NOT EXISTS "users" ("id" INTEGER PRIMARY KEY AUTOINCREMENT, "name" TEXT NOT NULL, "email" TEXT DEFAULT "" NOT NULL, "password" TEXT NOT NULL, "role" INTEGER DEFAULT 0 NOT NULL, "permission" INTEGER DEFAULT 0 NOT NULL, "template" TEXT DEFAULT "default" NOT NULL)')
-
-        self.c.execute('CREATE VIEW IF NOT EXISTS "pstats" AS \
-        SELECT p.id AS id, SUM(l.size) AS sizetotal, COUNT(l.id) AS linkstotal, linksdone, sizedone\
-        FROM packages p JOIN links l ON p.id = l.package LEFT OUTER JOIN\
-        (SELECT p.id AS id, COUNT(*) AS linksdone, SUM(l.size) AS sizedone \
-        FROM packages p JOIN links l ON p.id = l.package AND l.status in (0,4,13) GROUP BY p.id) s ON s.id = p.id \
-        GROUP BY p.id')
+        self.c.execute(
+            'CREATE TABLE IF NOT EXISTS "packages" ('
+            '"pid" INTEGER PRIMARY KEY AUTOINCREMENT, '
+            '"name" TEXT NOT NULL, '
+            '"folder" TEXT DEFAULT "" NOT NULL, '
+            '"site" TEXT DEFAULT "" NOT NULL, '
+            '"comment" TEXT DEFAULT "" NOT NULL, '
+            '"password" TEXT DEFAULT "" NOT NULL, '
+            '"added" INTEGER DEFAULT 0 NOT NULL,' # set by trigger
+            '"status" INTEGER DEFAULT 0 NOT NULL,'
+            '"tags" TEXT DEFAULT "" NOT NULL,'
+            '"shared" INTEGER DEFAULT 0 NOT NULL,'
+            '"packageorder" INTEGER DEFAULT -1 NOT NULL,' #incremented by trigger
+            '"root" INTEGER DEFAULT -1 NOT NULL, '
+            '"owner" INTEGER NOT NULL, '
+            'FOREIGN KEY(owner) REFERENCES users(uid), '
+            'CHECK (root != pid)'
+            ')'
+        )
+
+        self.c.execute(
+            'CREATE TRIGGER IF NOT EXISTS "insert_package" AFTER INSERT ON "packages"'
+            'BEGIN '
+            'UPDATE packages SET added = strftime("%s", "now"), '
+            'packageorder = (SELECT max(p.packageorder) + 1 FROM packages p WHERE p.root=new.root) '
+            'WHERE rowid = new.rowid;'
+            'END'
+        )
+
+        self.c.execute(
+            'CREATE TRIGGER IF NOT EXISTS "delete_package" AFTER DELETE ON "packages"'
+            'BEGIN '
+            'DELETE FROM files WHERE package = old.pid;'
+            'UPDATE packages SET packageorder=packageorder-1 WHERE packageorder > old.packageorder AND root=old.pid;'
+            'END'
+        )
+        self.c.execute('CREATE INDEX IF NOT EXISTS "package_index" ON packages(root, owner)')
+        self.c.execute('CREATE INDEX IF NOT EXISTS "package_owner" ON packages(owner)')
+
+        self.c.execute(
+            'CREATE TABLE IF NOT EXISTS "files" ('
+            '"fid" INTEGER PRIMARY KEY AUTOINCREMENT, '
+            '"name" TEXT NOT NULL, '
+            '"size" INTEGER DEFAULT 0 NOT NULL, '
+            '"status" INTEGER DEFAULT 0 NOT NULL, '
+            '"media" INTEGER DEFAULT 1 NOT NULL,'
+            '"added" INTEGER DEFAULT 0 NOT NULL,'
+            '"fileorder" INTEGER DEFAULT -1 NOT NULL, '
+            '"url" TEXT DEFAULT "" NOT NULL, '
+            '"plugin" TEXT DEFAULT "" NOT NULL, '
+            '"hash" TEXT DEFAULT "" NOT NULL, '
+            '"dlstatus" INTEGER DEFAULT 0 NOT NULL, '
+            '"error" TEXT DEFAULT "" NOT NULL, '
+            '"package" INTEGER NOT NULL, '
+            '"owner" INTEGER NOT NULL, '
+            'FOREIGN KEY(owner) REFERENCES users(uid), '
+            'FOREIGN KEY(package) REFERENCES packages(id)'
+            ')'
+        )
+        self.c.execute('CREATE INDEX IF NOT EXISTS "file_index" ON files(package, owner)')
+        self.c.execute('CREATE INDEX IF NOT EXISTS "file_owner" ON files(owner)')
+
+        self.c.execute(
+            'CREATE TRIGGER IF NOT EXISTS "insert_file" AFTER INSERT ON "files"'
+            'BEGIN '
+            'UPDATE files SET added = strftime("%s", "now"), '
+            'fileorder = (SELECT max(f.fileorder) + 1 FROM files f WHERE f.package=new.package) '
+            'WHERE rowid = new.rowid;'
+            'END'
+        )
+
+        self.c.execute(
+            'CREATE TABLE IF NOT EXISTS "collector" ('
+            '"owner" INTEGER NOT NULL, '
+            '"data" TEXT NOT NULL, '
+            'FOREIGN KEY(owner) REFERENCES users(uid), '
+            'PRIMARY KEY(owner) ON CONFLICT REPLACE'
+            ') '
+        )
+
+        self.c.execute(
+            'CREATE TABLE IF NOT EXISTS "storage" ('
+            '"identifier" TEXT NOT NULL, '
+            '"key" TEXT NOT NULL, '
+            '"value" TEXT DEFAULT "", '
+            'PRIMARY KEY (identifier, key) ON CONFLICT REPLACE'
+            ')'
+        )
+
+        self.c.execute(
+            'CREATE TABLE IF NOT EXISTS "users" ('
+            '"uid" INTEGER PRIMARY KEY AUTOINCREMENT, '
+            '"name" TEXT NOT NULL UNIQUE, '
+            '"email" TEXT DEFAULT "" NOT NULL, '
+            '"password" TEXT NOT NULL, '
+            '"role" INTEGER DEFAULT 0 NOT NULL, '
+            '"permission" INTEGER DEFAULT 0 NOT NULL, '
+            '"folder" TEXT DEFAULT "" NOT NULL, '
+            '"traffic" INTEGER DEFAULT -1 NOT NULL, '
+            '"dllimit" INTEGER DEFAULT -1 NOT NULL, '
+            '"dlquota" TEXT DEFAULT "" NOT NULL, '
+            '"hddquota" INTEGER DEFAULT -1 NOT NULL, '
+            '"template" TEXT DEFAULT "default" NOT NULL, '
+            '"user" INTEGER DEFAULT -1 NOT NULL, ' # set by trigger to self
+            'FOREIGN KEY(user) REFERENCES users(uid)'
+            ')'
+        )
+        self.c.execute('CREATE INDEX IF NOT EXISTS "username_index" ON users(name)')
+
+        self.c.execute(
+            'CREATE TRIGGER IF NOT EXISTS "insert_user" AFTER INSERT ON "users"'
+            'BEGIN '
+            'UPDATE users SET user = new.uid, folder=new.name '
+            'WHERE rowid = new.rowid;'
+            'END'
+        )
+
+        self.c.execute(
+            'CREATE TABLE IF NOT EXISTS "settings" ('
+            '"plugin" TEXT NOT NULL, '
+            '"user" INTEGER DEFAULT -1 NOT NULL, '
+            '"config" TEXT NOT NULL, '
+            'FOREIGN KEY(user) REFERENCES users(uid), '
+            'PRIMARY KEY (plugin, user) ON CONFLICT REPLACE'
+            ')'
+        )
+
+        self.c.execute(
+            'CREATE TABLE IF NOT EXISTS "accounts" ('
+            '"plugin" TEXT NOT NULL, '
+            '"loginname" TEXT NOT NULL, '
+            '"owner", INTEGER NOT NULL, '
+            '"activated" INTEGER DEFAULT 1, '
+            '"password" TEXT DEFAULT "", '
+            '"shared" INTEGER DEFAULT 0, '
+            '"options" TEXT DEFAULT "", '
+            'FOREIGN KEY(owner) REFERENCES users(uid), '
+            'PRIMARY KEY (plugin, loginname, owner) ON CONFLICT REPLACE'
+            ')'
+        )
+
+        self.c.execute(
+            'CREATE TABLE IF NOT EXISTS "stats" ('
+            '"user" INTEGER NOT NULL, '
+            '"plugin" TEXT NOT NULL, '
+            '"time" INTEGER NOT NULL, '
+            '"premium" INTEGER DEFAULT 0 NOT NULL, '
+            '"amount" INTEGER DEFAULT 0 NOT NULL, '
+            'FOREIGN KEY(user) REFERENCES users(uid), '
+            'PRIMARY KEY(user, plugin, time)'
+            ')'
+        )
+        self.c.execute('CREATE INDEX IF NOT EXISTS "stats_time" ON stats(time)')
 
         #try to lower ids
-        self.c.execute('SELECT max(id) FROM LINKS')
+        self.c.execute('SELECT max(fid) FROM files')
         fid = self.c.fetchone()[0]
-        if fid:
-            fid = int(fid)
-        else:
-            fid = 0
-        self.c.execute('UPDATE SQLITE_SEQUENCE SET seq=? WHERE name=?', (fid, "links"))
+        fid = int(fid) if fid else 0
+        self.c.execute('UPDATE SQLITE_SEQUENCE SET seq=? WHERE name=?', (fid, "files"))
 
-
-        self.c.execute('SELECT max(id) FROM packages')
+        self.c.execute('SELECT max(pid) FROM packages')
         pid = self.c.fetchone()[0]
-        if pid:
-            pid = int(pid)
-        else:
-            pid = 0
+        pid = int(pid) if pid else 0
         self.c.execute('UPDATE SQLITE_SEQUENCE SET seq=? WHERE name=?', (pid, "packages"))
 
         self.c.execute('VACUUM')
 
 
-    def _migrateUser(self):
-        if exists("pyload.db"):
-            try:
-                self.core.log.info(_("Converting old Django DB"))
-            except:
-                print "Converting old Django DB"
-            conn = sqlite3.connect('pyload.db')
-            c = conn.cursor()
-            c.execute("SELECT username, password, email from auth_user WHERE is_superuser")
-            users = []
-            for r in c:
-                pw = r[1].split("$")
-                users.append((r[0], pw[1] + pw[2], r[2]))
-            c.close()
-            conn.close()
-
-            self.c.executemany("INSERT INTO users(name, password, email) VALUES (?, ?, ?)", users)
-            move("pyload.db", "pyload.old.db")
-    
     def createCursor(self):
         return self.conn.cursor()
-    
-    @style.async
+
+    @async
     def commit(self):
         self.conn.commit()
 
-    @style.queue
+    @queue
     def syncSave(self):
         self.conn.commit()
-    
-    @style.async
+
+    @async
     def rollback(self):
         self.conn.rollback()
-    
+
     def async(self, f, *args, **kwargs):
         args = (self, ) + args
         job = DatabaseJob(f, *args, **kwargs)
         self.jobs.put(job)
-    
+
     def queue(self, f, *args, **kwargs):
         args = (self, ) + args
         job = DatabaseJob(f, *args, **kwargs)
         self.jobs.put(job)
-        job.wait()
+        # only wait when db is running
+        if self.running.isSet(): job.wait()
         return job.result
-    
+
     @classmethod
     def registerSub(cls, klass):
         cls.subs.append(klass)
-    
+
     @classmethod
     def unregisterSub(cls, klass):
         cls.subs.remove(klass)
-    
+
     def __getattr__(self, attr):
         for sub in DatabaseBackend.subs:
             if hasattr(sub, attr):
                 return getattr(sub, attr)
+        raise AttributeError(attr)
 
 if __name__ == "__main__":
     db = DatabaseBackend()
     db.setup()
-    
+
     class Test():
-        @style.queue
+        @queue
         def insert(db):
             c = db.createCursor()
             for i in range(1000):
                 c.execute("INSERT INTO storage (identifier, key, value) VALUES (?, ?, ?)", ("foo", i, "bar"))
-        @style.async
+
+        @async
         def insert2(db):
             c = db.createCursor()
-            for i in range(1000*1000):
+            for i in range(1000 * 1000):
                 c.execute("INSERT INTO storage (identifier, key, value) VALUES (?, ?, ?)", ("foo", i, "bar"))
-        
-        @style.queue
+
+        @queue
         def select(db):
             c = db.createCursor()
             for i in range(10):
                 res = c.execute("SELECT value FROM storage WHERE identifier=? AND key=?", ("foo", i))
                 print res.fetchone()
-        
-        @style.queue
+
+        @queue
         def error(db):
             c = db.createCursor()
             print "a"
             c.execute("SELECT myerror FROM storage WHERE identifier=? AND key=?", ("foo", i))
             print "e"
-    
+
     db.registerSub(Test)
     from time import time
+
     start = time()
     for i in range(100):
         db.insert()
     end = time()
-    print end-start
-    
+    print end - start
+
     start = time()
     db.insert2()
     end = time()
-    print end-start
-    
+    print end - start
+
     db.error()
 
diff --git a/module/database/FileDatabase.py b/module/database/FileDatabase.py
index 7e7efb028..67a15912a 100644
--- a/module/database/FileDatabase.py
+++ b/module/database/FileDatabase.py
@@ -1,944 +1,446 @@
 #!/usr/bin/env python
-"""
-    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.
+# -*- coding: utf-8 -*-
 
-    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.
+###############################################################################
+#   Copyright(c) 2008-2012 pyLoad Team
+#   http://www.pyload.org
+#
+#   This program is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU Affero General Public License as
+#   published by the Free Software Foundation, either version 3 of the
+#   License, or (at your option) any later version.
+#
+#   Subjected to the terms and conditions in LICENSE
+#
+#   @author: RaNaN
+###############################################################################
 
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, see <http://www.gnu.org/licenses/>.
+from new_collections import OrderedDict
 
-    @author: RaNaN
-    @author: mkaay
-"""
+from module.Api import DownloadInfo, FileInfo, PackageInfo, PackageStats, DownloadState as DS, state_string
+from module.database import DatabaseMethods, queue, async, inner
 
+zero_stats = PackageStats(0, 0, 0, 0)
 
-from threading import RLock
-from time import time
 
-from module.utils import formatSize, lock
-from module.PullEvents import InsertEvent, ReloadAllEvent, RemoveEvent, UpdateEvent
-from module.PyPackage import PyPackage
-from module.PyFile import PyFile
-from module.database import style, DatabaseBackend
+class FileMethods(DatabaseMethods):
 
-try:
-    from pysqlite2 import dbapi2 as sqlite3
-except:
-    import sqlite3
-
-
-class FileHandler:
-    """Handles all request made to obtain information,
-    modify status or other request for links or packages"""
-
-    def __init__(self, core):
-        """Constructor"""
-        self.core = core
-
-        # translations
-        self.statusMsg = [_("finished"), _("offline"), _("online"), _("queued"), _("skipped"), _("waiting"), _("temp. offline"), _("starting"), _("failed"), _("aborted"), _("decrypting"), _("custom"), _("downloading"), _("processing"), _("unknown")]
-
-        self.cache = {} #holds instances for files
-        self.packageCache = {}  # same for packages
-        #@TODO: purge the cache
-
-        self.jobCache = {}
-
-        self.lock = RLock()  #@TODO should be a Lock w/o R
-        #self.lock._Verbose__verbose = True
-
-        self.filecount = -1 # if an invalid value is set get current value from db
-        self.queuecount = -1 #number of package to be loaded
-        self.unchanged = False #determines if any changes was made since last call
-
-        self.db = self.core.db
-
-    def change(func):
-        def new(*args):
-            args[0].unchanged = False
-            args[0].filecount = -1
-            args[0].queuecount = -1
-            args[0].jobCache = {}
-            return func(*args)
-        return new
-
-    #----------------------------------------------------------------------
-    def save(self):
-        """saves all data to backend"""
-        self.db.commit()
-
-    #----------------------------------------------------------------------
-    def syncSave(self):
-        """saves all data to backend and waits until all data are written"""
-        pyfiles = self.cache.values()
-        for pyfile in pyfiles:
-            pyfile.sync()
-
-        pypacks = self.packageCache.values()
-        for pypack in pypacks:
-            pypack.sync()
-
-        self.db.syncSave()
-
-    @lock
-    def getCompleteData(self, queue=1):
-        """gets a complete data representation"""
-
-        data = self.db.getAllLinks(queue)
-        packs = self.db.getAllPackages(queue)
-
-        data.update([(x.id, x.toDbDict()[x.id]) for x in self.cache.values()])
-
-        for x in self.packageCache.itervalues():
-            if x.queue != queue or x.id not in packs: continue
-            packs[x.id].update(x.toDict()[x.id])
-
-        for key, value in data.iteritems():
-            if value["package"] in packs:
-                packs[value["package"]]["links"][key] = value
-
-        return packs
-
-    @lock
-    def getInfoData(self, queue=1):
-        """gets a data representation without links"""
-
-        packs = self.db.getAllPackages(queue)
-        for x in self.packageCache.itervalues():
-            if x.queue != queue or x.id not in packs: continue
-            packs[x.id].update(x.toDict()[x.id])
-
-        return packs
-
-    @lock
-    @change
-    def addLinks(self, urls, package):
-        """adds links"""
-
-        self.core.hookManager.dispatchEvent("linksAdded", urls, package)
-
-        data = self.core.pluginManager.parseUrls(urls)
-
-        self.db.addLinks(data, package)
-        self.core.threadManager.createInfoThread(data, package)
-
-        #@TODO change from reloadAll event to package update event
-        self.core.pullManager.addEvent(ReloadAllEvent("collector"))
-
-    #----------------------------------------------------------------------
-    @lock
-    @change
-    def addPackage(self, name, folder, queue=0):
-        """adds a package, default to link collector"""
-        lastID = self.db.addPackage(name, folder, queue)
-        p = self.db.getPackage(lastID)
-        e = InsertEvent("pack", lastID, p.order, "collector" if not queue else "queue")
-        self.core.pullManager.addEvent(e)
-        return lastID
-
-    #----------------------------------------------------------------------
-    @lock
-    @change
-    def deletePackage(self, id):
-        """delete package and all contained links"""
-
-        p = self.getPackage(id)
-        if not p:
-            if id in self.packageCache: del self.packageCache[id]
-            return
-
-        oldorder = p.order
-        queue = p.queue
-
-        e = RemoveEvent("pack", id, "collector" if not p.queue else "queue")
-
-        pyfiles = self.cache.values()
-
-        for pyfile in pyfiles:
-            if pyfile.packageid == id:
-                pyfile.abortDownload()
-                pyfile.release()
-
-        self.db.deletePackage(p)
-        self.core.pullManager.addEvent(e)
-        self.core.hookManager.dispatchEvent("packageDeleted", id)
-
-        if id in self.packageCache:
-            del self.packageCache[id]
-
-        packs = self.packageCache.values()
-        for pack in packs:
-            if pack.queue == queue and pack.order > oldorder:
-                pack.order -= 1
-                pack.notifyChange()
-
-    #----------------------------------------------------------------------
-    @lock
-    @change
-    def deleteLink(self, id):
-        """deletes links"""
-
-        f = self.getFile(id)
-        if not f:
-            return None
-
-        pid = f.packageid
-        e = RemoveEvent("file", id, "collector" if not f.package().queue else "queue")
-        
-        oldorder = f.order
-
-        if id in self.core.threadManager.processingIds():
-            self.cache[id].abortDownload()
-
-        if id in self.cache:
-            del self.cache[id]
-
-        self.db.deleteLink(f)
-
-        self.core.pullManager.addEvent(e)
-
-        p = self.getPackage(pid)
-        if not len(p.getChildren()):
-            p.delete()
-                        
-        pyfiles = self.cache.values()
-        for pyfile in pyfiles:
-            if pyfile.packageid == pid and pyfile.order > oldorder:
-                pyfile.order -= 1
-                pyfile.notifyChange()
-
-    #----------------------------------------------------------------------
-    def releaseLink(self, id):
-        """removes pyfile from cache"""
-        if id in self.cache:
-            del self.cache[id]
-
-    #----------------------------------------------------------------------
-    def releasePackage(self, id):
-        """removes package from cache"""
-        if id in self.packageCache:
-            del self.packageCache[id]
-
-    #----------------------------------------------------------------------
-    def updateLink(self, pyfile):
-        """updates link"""
-        self.db.updateLink(pyfile)
-
-        e = UpdateEvent("file", pyfile.id, "collector" if not pyfile.package().queue else "queue")
-        self.core.pullManager.addEvent(e)
-
-    #----------------------------------------------------------------------
-    def updatePackage(self, pypack):
-        """updates a package"""
-        self.db.updatePackage(pypack)
-
-        e = UpdateEvent("pack", pypack.id, "collector" if not pypack.queue else "queue")
-        self.core.pullManager.addEvent(e)
-
-    #----------------------------------------------------------------------
-    def getPackage(self, id):
-        """return package instance"""
-
-        if id in self.packageCache:
-            return self.packageCache[id]
-        else:
-            return self.db.getPackage(id)
-
-    #----------------------------------------------------------------------
-    def getPackageData(self, id):
-        """returns dict with package information"""
-        pack = self.getPackage(id)
-
-        if not pack:
-            return None
-
-        pack = pack.toDict()[id]
-
-        data = self.db.getPackageData(id)
-
-        tmplist = []
-
-        cache = self.cache.values()
-        for x in cache:
-            if int(x.toDbDict()[x.id]["package"]) == int(id):
-                tmplist.append((x.id, x.toDbDict()[x.id]))
-        data.update(tmplist)
-
-        pack["links"] = data
-
-        return pack
-
-    #----------------------------------------------------------------------
-    def getFileData(self, id):
-        """returns dict with file information"""
-        if id in self.cache:
-            return self.cache[id].toDbDict()
-
-        return self.db.getLinkData(id)
+    @queue
+    def filecount(self):
+        """returns number of files, currently only used for debugging"""
+        self.c.execute("SELECT COUNT(*) FROM files")
+        return self.c.fetchone()[0]
 
-    #----------------------------------------------------------------------
-    def getFile(self, id):
-        """returns pyfile instance"""
-        if id in self.cache:
-            return self.cache[id]
+    @queue
+    def downloadstats(self, user=None):
+        """ number of downloads and size """
+        if user is None:
+            self.c.execute("SELECT COUNT(*), SUM(f.size) FROM files f WHERE dlstatus != 0")
         else:
-            return self.db.getFile(id)
-
-    #----------------------------------------------------------------------
-    @lock
-    def getJob(self, occ):
-        """get suitable job"""
-
-        #@TODO clean mess
-        #@TODO improve selection of valid jobs
-
-        if occ in self.jobCache:
-            if self.jobCache[occ]:
-                id = self.jobCache[occ].pop()
-                if id == "empty":
-                    pyfile = None
-                    self.jobCache[occ].append("empty")
-                else:
-                    pyfile = self.getFile(id)
-            else:
-                jobs = self.db.getJob(occ)
-                jobs.reverse()
-                if not jobs:
-                    self.jobCache[occ].append("empty")
-                    pyfile = None
-                else:
-                    self.jobCache[occ].extend(jobs)
-                    pyfile = self.getFile(self.jobCache[occ].pop())
+            self.c.execute(
+                "SELECT COUNT(*), SUM(f.size) FROM files f, packages p WHERE f.package = p.pid  AND dlstatus != 0",
+                user)
 
+        r = self.c.fetchone()
+        # sum is None when no elements are added
+        return (r[0], r[1] if r[1] is not None else 0) if r else (0, 0)
+
+    @queue
+    def queuestats(self, user=None):
+        """ number and size of files in queue not finished yet"""
+        # status not in NA, finished, skipped
+        if user is None:
+            self.c.execute("SELECT COUNT(*), SUM(f.size) FROM files f WHERE dlstatus NOT IN (0,5,6)")
         else:
-            self.jobCache = {} #better not caching to much
-            jobs = self.db.getJob(occ)
-            jobs.reverse()
-            self.jobCache[occ] = jobs
-
-            if not jobs:
-                self.jobCache[occ].append("empty")
-                pyfile = None
-            else:
-                pyfile = self.getFile(self.jobCache[occ].pop())
-
-            #@TODO: maybe the new job has to be approved...
+            self.c.execute(
+                "SELECT COUNT(*), SUM(f.size) FROM files f, package p WHERE f.package = p.pid AND p.owner=? AND dlstatus NOT IN (0,5,6)",
+                user)
 
+        r = self.c.fetchone()
+        return (r[0], r[1] if r[1] is not None else 0) if r else (0, 0)
 
-        #pyfile = self.getFile(self.jobCache[occ].pop())
-        return pyfile
-
-    @lock
-    def getDecryptJob(self):
-        """return job for decrypting"""
-        if "decrypt" in self.jobCache:
-            return None
 
-        plugins = self.core.pluginManager.crypterPlugins.keys() + self.core.pluginManager.containerPlugins.keys()
-        plugins = str(tuple(plugins))
+    # TODO: multi user?
+    @queue
+    def processcount(self, fid=-1, user=None):
+        """ number of files which have to be processed """
+        # status in online, queued, starting, waiting, downloading
+        self.c.execute("SELECT COUNT(*), SUM(size) FROM files WHERE dlstatus IN (2,3,8,9,10) AND fid != ?", (fid, ))
+        return self.c.fetchone()[0]
 
-        jobs = self.db.getPluginJob(plugins)
-        if jobs:
-            return self.getFile(jobs[0])
+    @queue
+    def processstats(self, user=None):
+        if user is None:
+            self.c.execute("SELECT COUNT(*), SUM(size) FROM files WHERE dlstatus IN (2,3,8,9,10)")
         else:
-            self.jobCache["decrypt"] = "empty"
-            return None
-
-    def getFileCount(self):
-        """returns number of files"""
+            self.c.execute(
+                "SELECT COUNT(*), SUM(f.size) FROM files f, packages p WHERE f.package = p.pid  AND dlstatus IN (2,3,8,9,10)",
+                user)
+        r = self.c.fetchone()
+        return (r[0], r[1] if r[1] is not None else 0) if r else (0, 0)
 
-        if self.filecount == -1:
-            self.filecount = self.db.filecount(1)
+    @queue
+    def addLink(self, url, name, plugin, package, owner):
+        # mark file status initially as missing, dlstatus - queued
+        self.c.execute('INSERT INTO files(url, name, plugin, status, dlstatus, package, owner) VALUES(?,?,?,1,3,?,?)',
+                       (url, name, plugin, package, owner))
+        return self.c.lastrowid
 
-        return self.filecount
+    @async
+    def addLinks(self, links, package, owner):
+        """ links is a list of tuples (url, plugin)"""
+        links = [(x[0], x[0], x[1], package, owner) for x in links]
+        self.c.executemany(
+            'INSERT INTO files(url, name, plugin, status, dlstatus, package, owner) VALUES(?,?,?,1,3,?,?)',
+            links)
+
+    @queue
+    def addFile(self, name, size, media, package, owner):
+        # file status - ok, dl status NA
+        self.c.execute('INSERT INTO files(name, size, media, package, owner) VALUES(?,?,?,?,?)',
+                       (name, size, media, package, owner))
+        return self.c.lastrowid
 
-    def getQueueCount(self, force=False):
-        """number of files that have to be processed"""
-        if self.queuecount == -1 or force:
-            self.queuecount = self.db.queuecount(1)
+    @queue
+    def addPackage(self, name, folder, root, password, site, comment, status, owner):
+        self.c.execute(
+            'INSERT INTO packages(name, folder, root, password, site, comment, status, owner) VALUES(?,?,?,?,?,?,?,?)'
+            , (name, folder, root, password, site, comment, status, owner))
+        return self.c.lastrowid
 
-        return self.queuecount
+    @async
+    def deletePackage(self, pid, owner=None):
+        # order updated by trigger, as well as links deleted
+        if owner is None:
+            self.c.execute('DELETE FROM packages WHERE pid=?', (pid,))
+        else:
+            self.c.execute('DELETE FROM packages WHERE pid=? AND owner=?', (pid, owner))
+
+    @async
+    def deleteFile(self, fid, order, package, owner=None):
+        """ To delete a file order and package of it is needed """
+        if owner is None:
+            self.c.execute('DELETE FROM files WHERE fid=?', (fid,))
+            self.c.execute('UPDATE files SET fileorder=fileorder-1 WHERE fileorder > ? AND package=?',
+                           (order, package))
+        else:
+            self.c.execute('DELETE FROM files WHERE fid=? AND owner=?', (fid, owner))
+            self.c.execute('UPDATE files SET fileorder=fileorder-1 WHERE fileorder > ? AND package=? AND owner=?',
+                           (order, package, owner))
+
+    @async
+    def saveCollector(self, owner, data):
+        """ simply save the json string to database """
+        self.c.execute("INSERT INTO collector(owner, data) VALUES (?,?)", (owner, data))
+
+    @queue
+    def retrieveCollector(self, owner):
+        """ retrieve the saved string """
+        self.c.execute('SELECT data FROM collector WHERE owner=?', (owner,))
+        r = self.c.fetchone()
+        if not r: return None
+        return r[0]
 
-    def checkAllLinksFinished(self):
-        """checks if all files are finished and dispatch event"""
+    @async
+    def deleteCollector(self, owner):
+        """ drop saved user collector """
+        self.c.execute('DELETE FROM collector WHERE owner=?', (owner,))
 
-        if not self.getQueueCount(True):
-            self.core.hookManager.dispatchEvent("allDownloadsFinished")
-            self.core.log.debug("All downloads finished")
-            return True
+    @queue
+    def getAllFiles(self, package=None, search=None, state=None, owner=None):
+        """ Return dict with file information
 
-        return False
+        :param package: optional package to filter out
+        :param search: or search string for file name
+        :param unfinished: filter by dlstatus not finished
+        :param owner: only specific owner
+        """
+        qry = ('SELECT fid, name, owner, size, status, media, added, fileorder, '
+               'url, plugin, hash, dlstatus, error, package FROM files WHERE ')
 
-    def checkAllLinksProcessed(self, fid):
-        """checks if all files was processed and pyload would idle now, needs fid which will be ignored when counting"""
+        arg = []
 
-        # reset count so statistic will update (this is called when dl was processed)
-        self.resetCount()
+        if state is not None and state != DS.All:
+            qry += 'dlstatus IN (%s) AND ' % state_string(state)
+        if owner is not None:
+            qry += 'owner=? AND '
+            arg.append(owner)
 
-        if not self.db.processcount(1, fid):
-            self.core.hookManager.dispatchEvent("allDownloadsProcessed")
-            self.core.log.debug("All downloads processed")
-            return True
+        if package is not None:
+            arg.append(package)
+            qry += 'package=? AND '
+        if search is not None:
+            search = "%%%s%%" % search.strip("%")
+            arg.append(search)
+            qry += "name LIKE ? "
 
-        return False
+        # make qry valid
+        if qry.endswith("WHERE "): qry = qry[:-6]
+        if qry.endswith("AND "): qry = qry[:-4]
 
-    def resetCount(self):
-        self.queuecount = -1
+        self.c.execute(qry + "ORDER BY package, fileorder", arg)
 
-    @lock
-    @change
-    def restartPackage(self, id):
-        """restart package"""
-        pyfiles = self.cache.values()
-        for pyfile in pyfiles:
-            if pyfile.packageid == id:
-                self.restartFile(pyfile.id)
+        data = OrderedDict()
+        for r in self.c:
+            f = FileInfo(r[0], r[1], r[13], r[2], r[3], r[4], r[5], r[6], r[7])
+            if r[11] > 0: # dl status != NA
+                f.download = DownloadInfo(r[8], r[9], r[10], r[11], self.manager.statusMsg[r[11]], r[12])
 
-        self.db.restartPackage(id)
-
-        if id in self.packageCache:
-            self.packageCache[id].setFinished = False
-
-        e = UpdateEvent("pack", id, "collector" if not self.getPackage(id).queue else "queue")
-        self.core.pullManager.addEvent(e)
-
-    @lock
-    @change
-    def restartFile(self, id):
-        """ restart file"""
-        if id in self.cache:
-            self.cache[id].status = 3
-            self.cache[id].name = self.cache[id].url
-            self.cache[id].error = ""
-            self.cache[id].abortDownload()
-
-
-        self.db.restartFile(id)
-
-        e = UpdateEvent("file", id, "collector" if not self.getFile(id).package().queue else "queue")
-        self.core.pullManager.addEvent(e)
-
-    @lock
-    @change
-    def setPackageLocation(self, id, queue):
-        """push package to queue"""
-
-        p = self.db.getPackage(id)
-        oldorder = p.order
-
-        e = RemoveEvent("pack", id, "collector" if not p.queue else "queue")
-        self.core.pullManager.addEvent(e)
-        
-        self.db.clearPackageOrder(p)
-
-        p = self.db.getPackage(id)
+            data[r[0]] = f
 
-        p.queue = queue
-        self.db.updatePackage(p)
-
-        self.db.reorderPackage(p, -1, True)
-        
-        packs = self.packageCache.values()
-        for pack in packs:
-            if pack.queue != queue and pack.order > oldorder:
-                pack.order -= 1
-                pack.notifyChange()
+        return data
 
-        self.db.commit()
-        self.releasePackage(id)
-        p = self.getPackage(id)
-        
-        e = InsertEvent("pack", id, p.order, "collector" if not p.queue else "queue")
-        self.core.pullManager.addEvent(e)
-
-    @lock
-    @change
-    def reorderPackage(self, id, position):
-        p = self.getPackage(id)
-
-        e = RemoveEvent("pack", id, "collector" if not p.queue else "queue")
-        self.core.pullManager.addEvent(e)
-        self.db.reorderPackage(p, position)
-
-        packs = self.packageCache.values()
-        for pack in packs:
-            if pack.queue != p.queue or pack.order < 0 or pack == p: continue
-            if p.order > position:
-                if pack.order >= position and pack.order < p.order:
-                    pack.order += 1
-                    pack.notifyChange()
-            elif p.order < position:
-                if pack.order <= position and pack.order > p.order:
-                    pack.order -= 1
-                    pack.notifyChange()
-
-        p.order = position
-        self.db.commit()
-
-        e = InsertEvent("pack", id, position, "collector" if not p.queue else "queue")
-        self.core.pullManager.addEvent(e)
-
-    @lock
-    @change
-    def reorderFile(self, id, position):
-        f = self.getFileData(id)
-        f = f[id]
-
-        e = RemoveEvent("file", id, "collector" if not self.getPackage(f["package"]).queue else "queue")
-        self.core.pullManager.addEvent(e)
-
-        self.db.reorderLink(f, position)
-
-        pyfiles = self.cache.values()
-        for pyfile in pyfiles:
-            if pyfile.packageid != f["package"] or pyfile.order < 0: continue
-            if f["order"] > position:
-                if pyfile.order >= position and pyfile.order < f["order"]:
-                    pyfile.order += 1
-                    pyfile.notifyChange()
-            elif f["order"] < position:
-                if pyfile.order <= position and pyfile.order > f["order"]:
-                    pyfile.order -= 1
-                    pyfile.notifyChange()
-
-        if id in self.cache:
-            self.cache[id].order = position
-
-        self.db.commit()
-
-        e = InsertEvent("file", id, position, "collector" if not self.getPackage(f["package"]).queue else "queue")
-        self.core.pullManager.addEvent(e)
-
-    @change
-    def updateFileInfo(self, data, pid):
-        """ updates file info (name, size, status, url)"""
-        ids = self.db.updateLinkInfo(data)
-        e = UpdateEvent("pack", pid, "collector" if not self.getPackage(pid).queue else "queue")
-        self.core.pullManager.addEvent(e)
-
-    def checkPackageFinished(self, pyfile):
-        """ checks if package is finished and calls hookmanager """
-
-        ids = self.db.getUnfinished(pyfile.packageid)
-        if not ids or (pyfile.id in ids and len(ids) == 1):
-            if not pyfile.package().setFinished:
-                self.core.log.info(_("Package finished: %s") % pyfile.package().name)
-                self.core.hookManager.packageFinished(pyfile.package())
-                pyfile.package().setFinished = True
-
-
-    def reCheckPackage(self, pid):
-        """ recheck links in package """
-        data = self.db.getPackageData(pid)
-
-        urls = []
-
-        for pyfile in data.itervalues():
-            if pyfile["status"] not in  (0, 12, 13):
-                urls.append((pyfile["url"], pyfile["plugin"]))
-
-        self.core.threadManager.createInfoThread(urls, pid)
-
-    @lock
-    @change
-    def deleteFinishedLinks(self):
-        """ deletes finished links and packages, return deleted packages """
-
-        old_packs = self.getInfoData(0)
-        old_packs.update(self.getInfoData(1))
-
-        self.db.deleteFinished()
-
-        new_packs = self.db.getAllPackages(0)
-        new_packs.update(self.db.getAllPackages(1))
-        #get new packages only from db
-
-        deleted = []
-        for id in old_packs.iterkeys():
-            if id not in new_packs:
-                deleted.append(id)
-                self.deletePackage(int(id))
-
-        return deleted
-
-    @lock
-    @change
-    def restartFailed(self):
-        """ restart all failed links """
-        self.db.restartFailed()
-
-class FileMethods():
-    @style.queue
-    def filecount(self, queue):
-        """returns number of files in queue"""
-        self.c.execute("SELECT COUNT(*) FROM links as l INNER JOIN packages as p ON l.package=p.id WHERE p.queue=?", (queue, ))
-        return self.c.fetchone()[0]
+    @queue
+    def getMatchingFilenames(self, pattern, owner=None):
+        """ Return matching file names for pattern, useful for search suggestions """
+        qry = 'SELECT name FROM files WHERE name LIKE ?'
+        args = ["%%%s%%" % pattern.strip("%")]
+        if owner:
+            qry += " AND owner=?"
+            args.append(owner)
 
-    @style.queue
-    def queuecount(self, queue):
-        """ number of files in queue not finished yet"""
-        self.c.execute("SELECT COUNT(*) FROM links as l INNER JOIN packages as p ON l.package=p.id WHERE p.queue=? AND l.status NOT IN (0,4)", (queue, ))
-        return self.c.fetchone()[0]
+        self.c.execute(qry, args)
+        return [r[0] for r in self.c]
 
-    @style.queue
-    def processcount(self, queue, fid):
-        """ number of files which have to be proccessed """
-        self.c.execute("SELECT COUNT(*) FROM links as l INNER JOIN packages as p ON l.package=p.id WHERE p.queue=? AND l.status IN (2,3,5,7,12) AND l.id != ?", (queue, str(fid)))
-        return self.c.fetchone()[0]
+    @queue
+    def getAllPackages(self, root=None, owner=None, tags=None):
+        """ Return dict with package information
 
-    @style.inner
-    def _nextPackageOrder(self, queue=0):
-        self.c.execute('SELECT MAX(packageorder) FROM packages WHERE queue=?', (queue,))
-        max = self.c.fetchone()[0]
-        if max is not None:
-            return max + 1
-        else:
-            return 0
-    
-    @style.inner
-    def _nextFileOrder(self, package):
-        self.c.execute('SELECT MAX(linkorder) FROM links WHERE package=?', (package,))
-        max = self.c.fetchone()[0]
-        if max is not None:
-            return max + 1
+        :param root: optional root to filter
+        :param owner: optional user id
+        :param tags: optional tag list
+        """
+        qry = (
+            'SELECT pid, name, folder, root, owner, site, comment, password, added, tags, status, shared, packageorder '
+            'FROM packages%s ORDER BY root, packageorder')
+
+        if root is None:
+            stats = self.getPackageStats(owner=owner)
+            if owner is None:
+                self.c.execute(qry % "")
+            else:
+                self.c.execute(qry % " WHERE owner=?", (owner,))
         else:
-            return 0
-    
-    @style.queue
-    def addLink(self, url, name, plugin, package):
-        order = self._nextFileOrder(package)
-        self.c.execute('INSERT INTO links(url, name, plugin, package, linkorder) VALUES(?,?,?,?,?)', (url, name, plugin, package, order))
-        return self.c.lastrowid
-
-    @style.queue
-    def addLinks(self, links, package):
-        """ links is a list of tupels (url,plugin)"""
-        order = self._nextFileOrder(package)
-        orders = [order + x for x in range(len(links))]
-        links = [(x[0], x[0], x[1], package, o) for x, o in zip(links, orders)]
-        self.c.executemany('INSERT INTO links(url, name, plugin, package, linkorder) VALUES(?,?,?,?,?)', links)
-
-    @style.queue
-    def addPackage(self, name, folder, queue):
-        order = self._nextPackageOrder(queue)
-        self.c.execute('INSERT INTO packages(name, folder, queue, packageorder) VALUES(?,?,?,?)', (name, folder, queue, order))
-        return self.c.lastrowid
-
-    @style.queue
-    def deletePackage(self, p):
-
-        self.c.execute('DELETE FROM links WHERE package=?', (str(p.id),))
-        self.c.execute('DELETE FROM packages WHERE id=?', (str(p.id),))
-        self.c.execute('UPDATE packages SET packageorder=packageorder-1 WHERE packageorder > ? AND queue=?', (p.order, p.queue))
-
-    @style.queue
-    def deleteLink(self, f):
-
-        self.c.execute('DELETE FROM links WHERE id=?', (str(f.id),))
-        self.c.execute('UPDATE links SET linkorder=linkorder-1 WHERE linkorder > ? AND package=?', (f.order, str(f.packageid)))
-
-
-    @style.queue
-    def getAllLinks(self, q):
-        """return information about all links in queue q
-
-        q0 queue
-        q1 collector
-
-        format:
-
-        {
-            id: {'name': name, ... 'package': id }, ...
-        }
+            stats = self.getPackageStats(root=root, owner=owner)
+            if owner is None:
+                self.c.execute(qry % ' WHERE root=? OR pid=?', (root, root))
+            else:
+                self.c.execute(qry % ' WHERE (root=? OR pid=?) AND owner=?', (root, root, owner))
 
-        """
-        self.c.execute('SELECT l.id,l.url,l.name,l.size,l.status,l.error,l.plugin,l.package,l.linkorder FROM links as l INNER JOIN packages as p ON l.package=p.id WHERE p.queue=? ORDER BY l.linkorder', (q,))
-        data = {}
+        data = OrderedDict()
         for r in self.c:
-            data[r[0]] = {
-                'id': r[0],
-                'url': r[1],
-                'name': r[2],
-                'size': r[3],
-                'format_size': formatSize(r[3]),
-                'status': r[4],
-                'statusmsg': self.manager.statusMsg[r[4]],
-                'error': r[5],
-                'plugin': r[6],
-                'package': r[7],
-                'order': r[8],
-            }
+            data[r[0]] = PackageInfo(
+                r[0], r[1], r[2], r[3], r[4], r[5], r[6], r[7], r[8], r[9].split(","), r[10], r[11], r[12],
+                stats.get(r[0], zero_stats)
+            )
 
         return data
 
-    @style.queue
-    def getAllPackages(self, q):
-        """return information about packages in queue q
-        (only useful in get all data)
-
-        q0 queue
-        q1 collector
-
-        format:
-
-        {
-            id: {'name': name ... 'links': {} }, ...
-        }
-        """
-        self.c.execute('SELECT p.id, p.name, p.folder, p.site, p.password, p.queue, p.packageorder, s.sizetotal, s.sizedone, s.linksdone, s.linkstotal \
-            FROM packages p JOIN pstats s ON p.id = s.id \
-            WHERE p.queue=? ORDER BY p.packageorder', str(q))
+    @inner
+    def getPackageStats(self, pid=None, root=None, owner=None):
+        qry = ("SELECT p.pid, SUM(f.size) AS sizetotal, COUNT(f.fid) AS linkstotal, sizedone, linksdone "
+               "FROM packages p JOIN files f ON p.pid = f.package AND f.dlstatus > 0 %(sub)s LEFT OUTER JOIN "
+               "(SELECT p.pid AS pid, SUM(f.size) AS sizedone, COUNT(f.fid) AS linksdone "
+               "FROM packages p JOIN files f ON p.pid = f.package %(sub)s AND f.dlstatus in (5,6) GROUP BY p.pid) s ON s.pid = p.pid "
+               "GROUP BY p.pid")
+
+        # status in (finished, skipped, processing)
+
+        if root is not None:
+            self.c.execute(qry % {"sub": "AND (p.root=:root OR p.pid=:root)"}, locals())
+        elif pid is not None:
+            self.c.execute(qry % {"sub": "AND p.pid=:pid"}, locals())
+        elif owner is not None:
+            self.c.execute(qry % {"sub": "AND p.owner=:owner"}, locals())
+        else:
+            self.c.execute(qry % {"sub": ""})
 
         data = {}
         for r in self.c:
-            data[r[0]] = {
-                'id': r[0],
-                'name': r[1],
-                'folder': r[2],
-                'site': r[3],
-                'password': r[4],
-                'queue': r[5],
-                'order': r[6],
-                'sizetotal': int(r[7]),
-                'sizedone': r[8] if r[8] else 0, #these can be None
-                'linksdone': r[9] if r[9] else 0,
-                'linkstotal': r[10],
-                'links': {}
-            }
+            data[r[0]] = PackageStats(
+                r[2] if r[2] else 0,
+                r[4] if r[4] else 0,
+                int(r[1]) if r[1] else 0,
+                int(r[3]) if r[3] else 0,
+            )
 
         return data
-    
-    @style.queue
-    def getLinkData(self, id):
-        """get link information as dict"""
-        self.c.execute('SELECT id,url,name,size,status,error,plugin,package,linkorder FROM links WHERE id=?', (str(id), ))
-        data = {}
+
+    @queue
+    def getStatsForPackage(self, pid):
+        return self.getPackageStats(pid=pid)[pid]
+
+    @queue
+    def getFileInfo(self, fid, force=False):
+        """get data for specific file, when force is true download info will be appended"""
+        self.c.execute('SELECT fid, name, owner, size, status, media, added, fileorder, '
+                       'url, plugin, hash, dlstatus, error, package FROM files '
+                       'WHERE fid=?', (fid,))
         r = self.c.fetchone()
         if not r:
             return None
-        data[r[0]] = {
-            'id': r[0],
-            'url': r[1],
-            'name': r[2],
-            'size': r[3],
-            'format_size': formatSize(r[3]),
-            'status': r[4],
-            'statusmsg': self.manager.statusMsg[r[4]],
-            'error': r[5],
-            'plugin': r[6],
-            'package': r[7],
-            'order': r[8],
-        }
-
-        return data
+        else:
+            f = FileInfo(r[0], r[1], r[13], r[2], r[3], r[4], r[5], r[6], r[7])
+            if r[11] > 0 or force:
+                f.download = DownloadInfo(r[8], r[9], r[10], r[11], self.manager.statusMsg[r[11]], r[12])
 
-    @style.queue
-    def getPackageData(self, id):
-        """get data about links for a package"""
-        self.c.execute('SELECT id,url,name,size,status,error,plugin,package,linkorder FROM links WHERE package=? ORDER BY linkorder', (str(id), ))
+            return f
 
-        data = {}
-        for r in self.c:
-            data[r[0]] = {
-                'id': r[0],
-                'url': r[1],
-                'name': r[2],
-                'size': r[3],
-                'format_size': formatSize(r[3]),
-                'status': r[4],
-                'statusmsg': self.manager.statusMsg[r[4]],
-                'error': r[5],
-                'plugin': r[6],
-                'package': r[7],
-                'order': r[8],
-            }
+    @queue
+    def getPackageInfo(self, pid, stats=True):
+        """get data for a specific package, optionally with package stats"""
+        if stats:
+            stats = self.getPackageStats(pid=pid)
 
-        return data
+        self.c.execute(
+            'SELECT pid, name, folder, root, owner, site, comment, password, added, tags, status, shared, packageorder '
+            'FROM packages WHERE pid=?', (pid,))
 
+        r = self.c.fetchone()
+        if not r:
+            return None
+        else:
+            return PackageInfo(
+                r[0], r[1], r[2], r[3], r[4], r[5], r[6], r[7], r[8], r[9].split(","), r[10], r[11], r[12],
+                stats.get(r[0], zero_stats) if stats else None
+            )
+
+    @async
+    def updateLinkInfo(self, data, owner):
+        """ data is list of tuples (name, size, status,[ hash,] url)"""
+        if data and len(data[0]) == 4:
+            self.c.executemany('UPDATE files SET name=?, size=?, dlstatus=? WHERE url=? AND dlstatus IN (0,1,2,3,14)',
+                               data)
+        else:
+            self.c.executemany(
+                'UPDATE files SET name=?, size=?, dlstatus=?, hash=? WHERE url=? AND dlstatus IN (0,1,2,3,14)', data)
 
-    @style.async
-    def updateLink(self, f):
-        self.c.execute('UPDATE links SET url=?,name=?,size=?,status=?,error=?,package=? WHERE id=?', (f.url, f.name, f.size, f.status, f.error, str(f.packageid), str(f.id)))
+    @async
+    def updateFile(self, f):
+        self.c.execute('UPDATE files SET name=?, size=?, status=?,'
+                       'media=?, url=?, hash=?, dlstatus=?, error=? WHERE fid=?',
+                       (f.name, f.size, f.filestatus, f.media, f.url,
+                        f.hash, f.status, f.error, f.fid))
 
-    @style.queue
+    @async
     def updatePackage(self, p):
-        self.c.execute('UPDATE packages SET name=?,folder=?,site=?,password=?,queue=? WHERE id=?', (p.name, p.folder, p.site, p.password, p.queue, str(p.id)))
-        
-    @style.queue    
-    def updateLinkInfo(self, data):
-        """ data is list of tupels (name, size, status, url) """
-        self.c.executemany('UPDATE links SET name=?, size=?, status=? WHERE url=? AND status IN (1,2,3,14)', data)
-        ids = []
-        self.c.execute('SELECT id FROM links WHERE url IN (\'%s\')' % "','".join([x[3] for x in data]))
-        for r in self.c:
-            ids.append(int(r[0]))
-        return ids
-        
-    @style.queue
-    def reorderPackage(self, p, position, noMove=False):
-        if position == -1:
-            position = self._nextPackageOrder(p.queue)
-        if not noMove:
-            if p.order > position:
-                self.c.execute('UPDATE packages SET packageorder=packageorder+1 WHERE packageorder >= ? AND packageorder < ? AND queue=? AND packageorder >= 0', (position, p.order, p.queue))
-            elif p.order < position:
-                self.c.execute('UPDATE packages SET packageorder=packageorder-1 WHERE packageorder <= ? AND packageorder > ? AND queue=? AND packageorder >= 0', (position, p.order, p.queue))
-
-        self.c.execute('UPDATE packages SET packageorder=? WHERE id=?', (position, str(p.id)))
-    
-    @style.queue
-    def reorderLink(self, f, position):
-        """ reorder link with f as dict for pyfile  """
-        if f["order"] > position:
-            self.c.execute('UPDATE links SET linkorder=linkorder+1 WHERE linkorder >= ? AND linkorder < ? AND package=?', (position, f["order"], f["package"]))
-        elif f["order"] < position:
-            self.c.execute('UPDATE links SET linkorder=linkorder-1 WHERE linkorder <= ? AND linkorder > ? AND package=?', (position, f["order"], f["package"]))
-
-        self.c.execute('UPDATE links SET linkorder=? WHERE id=?', (position, f["id"]))
-        
-        
-    @style.queue
-    def clearPackageOrder(self, p):
-        self.c.execute('UPDATE packages SET packageorder=? WHERE id=?', (-1, str(p.id)))
-        self.c.execute('UPDATE packages SET packageorder=packageorder-1 WHERE packageorder > ? AND queue=? AND id != ?', (p.order, p.queue, str(p.id)))
-    
-    @style.async
-    def restartFile(self, id):
-        self.c.execute('UPDATE links SET status=3,error="" WHERE id=?', (str(id),))
-
-    @style.async
-    def restartPackage(self, id):
-        self.c.execute('UPDATE links SET status=3 WHERE package=?', (str(id),))
-        
-    @style.queue
-    def getPackage(self, id):
-        """return package instance from id"""
-        self.c.execute("SELECT name,folder,site,password,queue,packageorder FROM packages WHERE id=?", (str(id), ))
+        self.c.execute(
+            'UPDATE packages SET name=?, folder=?, site=?, comment=?, password=?, tags=?, status=?, shared=? WHERE pid=?',
+            (p.name, p.folder, p.site, p.comment, p.password, ",".join(p.tags), p.status, p.shared, p.pid))
+
+    # TODO: most modifying methods needs owner argument to avoid checking beforehand
+    @async
+    def orderPackage(self, pid, root, oldorder, order):
+        if oldorder > order: # package moved upwards
+            self.c.execute(
+                'UPDATE packages SET packageorder=packageorder+1 WHERE packageorder >= ? AND packageorder < ? AND root=? AND packageorder >= 0'
+                , (order, oldorder, root))
+        elif oldorder < order: # moved downwards
+            self.c.execute(
+                'UPDATE packages SET packageorder=packageorder-1 WHERE packageorder <= ? AND packageorder > ? AND root=? AND packageorder >= 0'
+                , (order, oldorder, root))
+
+        self.c.execute('UPDATE packages SET packageorder=? WHERE pid=?', (order, pid))
+
+    @async
+    def orderFiles(self, pid, fids, oldorder, order):
+        diff = len(fids)
+        data = []
+
+        if oldorder > order: # moved upwards
+            self.c.execute('UPDATE files SET fileorder=fileorder+? WHERE fileorder >= ? AND fileorder < ? AND package=?'
+                , (diff, order, oldorder, pid))
+            data = [(order + i, fid) for i, fid in enumerate(fids)]
+        elif oldorder < order:
+            self.c.execute(
+                'UPDATE files SET fileorder=fileorder-? WHERE fileorder <= ? AND fileorder >= ? AND package=?'
+                , (diff, order, oldorder + diff, pid))
+            data = [(order - diff + i + 1, fid) for i, fid in enumerate(fids)]
+
+        self.c.executemany('UPDATE files SET fileorder=? WHERE fid=?', data)
+
+    @async
+    def moveFiles(self, pid, fids, package):
+        self.c.execute('SELECT max(fileorder) FROM files WHERE package=?', (package,))
         r = self.c.fetchone()
-        if not r: return None
-        return PyPackage(self.manager, id, * r)
+        order = (r[0] if r[0] else 0) + 1
+
+        self.c.execute('UPDATE files SET fileorder=fileorder-? WHERE fileorder > ? AND package=?',
+                       (len(fids), order, pid))
 
-    #----------------------------------------------------------------------
-    @style.queue
-    def getFile(self, id):
-        """return link instance from id"""
-        self.c.execute("SELECT url, name, size, status, error, plugin, package, linkorder FROM links WHERE id=?", (str(id), ))
+        data = [(package, order + i, fid) for i, fid in enumerate(fids)]
+        self.c.executemany('UPDATE files SET package=?, fileorder=? WHERE fid=?', data)
+
+    @async
+    def movePackage(self, root, order, pid, dpid):
+        self.c.execute('SELECT max(packageorder) FROM packages WHERE root=?', (dpid,))
         r = self.c.fetchone()
-        if not r: return None
-        return PyFile(self.manager, id, * r)
+        max = (r[0] if r[0] else 0) + 1
 
+        self.c.execute('UPDATE packages SET packageorder=packageorder-1 WHERE packageorder > ? AND root=?',
+                       (order, root))
 
-    @style.queue
-    def getJob(self, occ):
-        """return pyfile ids, which are suitable for download and dont use a occupied plugin"""
+        self.c.execute('UPDATE packages SET root=?, packageorder=? WHERE pid=?', (dpid, max, pid))
 
-        #@TODO improve this hardcoded method
-        pre = "('DLC', 'LinkList', 'SerienjunkiesOrg', 'CCF', 'RSDF')"  #plugins which are processed in collector
+    @async
+    def restartFile(self, fid):
+        # status -> queued
+        self.c.execute('UPDATE files SET dlstatus=3, error="" WHERE fid=?', (fid,))
 
-        cmd = "("
-        for i, item in enumerate(occ):
-            if i: cmd += ", "
-            cmd += "'%s'" % item
-        
-        cmd += ")"
+    @async
+    def restartPackage(self, pid):
+        # status -> queued
+        self.c.execute('UPDATE files SET status=3 WHERE package=?', (pid,))
 
-        cmd = "SELECT l.id FROM links as l INNER JOIN packages as p ON l.package=p.id WHERE ((p.queue=1 AND l.plugin NOT IN %s) OR l.plugin IN %s) AND l.status IN (2,3,14) ORDER BY p.packageorder ASC, l.linkorder ASC LIMIT 5" % (cmd, pre)
-            
-        self.c.execute(cmd) # very bad!
 
-        return [x[0] for x in self.c]
+    # TODO: multi user approach
+    @queue
+    def getJob(self, occ):
+        """return pyfile ids, which are suitable for download and don't use a occupied plugin"""
+        cmd = "(%s)" % ", ".join(["'%s'" % x for x in occ])
+        #TODO
 
-    @style.queue
-    def getPluginJob(self, plugins):
-        """returns pyfile ids with suited plugins"""
-        cmd = "SELECT l.id FROM links as l INNER JOIN packages as p ON l.package=p.id WHERE l.plugin IN %s AND l.status IN (2,3,14) ORDER BY p.packageorder ASC, l.linkorder ASC LIMIT 5" % plugins
+        # dlstatus in online, queued | package status = ok
+        cmd = ("SELECT f.fid FROM files as f INNER JOIN packages as p ON f.package=p.pid "
+               "WHERE f.plugin NOT IN %s AND f.dlstatus IN (2,3) AND p.status=0 "
+               "ORDER BY p.packageorder ASC, f.fileorder ASC LIMIT 5") % cmd
 
-        self.c.execute(cmd) # very bad!
+        self.c.execute(cmd)
 
         return [x[0] for x in self.c]
 
-    @style.queue
+    @queue
     def getUnfinished(self, pid):
         """return list of max length 3 ids with pyfiles in package not finished or processed"""
-        
-        self.c.execute("SELECT id FROM links WHERE package=? AND status NOT IN (0, 4, 13) LIMIT 3", (str(pid),))
-        return [r[0] for r in self.c]
 
-    @style.queue
-    def deleteFinished(self):
-        self.c.execute("DELETE FROM links WHERE status IN (0,4)")
-        self.c.execute("DELETE FROM packages WHERE NOT EXISTS(SELECT 1 FROM links WHERE packages.id=links.package)")
+        # status in finished, skipped, processing
+        self.c.execute("SELECT fid FROM files WHERE package=? AND dlstatus NOT IN (5, 6, 14) LIMIT 3", (pid,))
+        return [r[0] for r in self.c]
 
-    @style.queue
-    def restartFailed(self):
-        self.c.execute("UPDATE links SET status=3,error='' WHERE status IN (6, 8, 9)")
+    @queue
+    def restartFailed(self, owner):
+        # status=queued, where status in failed, aborted, temp offline
+        self.c.execute("UPDATE files SET dlstatus=3, error='' WHERE dlstatus IN (7, 11, 12)")
 
-    @style.queue
+    @queue
     def findDuplicates(self, id, folder, filename):
-        """ checks if filename exists with different id and same package """
-        self.c.execute("SELECT l.plugin FROM links as l INNER JOIN packages as p ON l.package=p.id AND p.folder=? WHERE l.id!=? AND l.status=0 AND l.name=?", (folder, id, filename))
+        """ checks if filename exists with different id and same package, dlstatus = finished """
+        # TODO: also check root of package
+        self.c.execute(
+            "SELECT f.plugin FROM files f INNER JOIN packages as p ON f.package=p.pid AND p.folder=? WHERE f.fid!=? AND f.dlstatus=5 AND f.name=?"
+            , (folder, id, filename))
         return self.c.fetchone()
 
-    @style.queue
+    @queue
     def purgeLinks(self):
-        self.c.execute("DELETE FROM links;")
-        self.c.execute("DELETE FROM packages;")
-
-DatabaseBackend.registerSub(FileMethods)
-
-if __name__ == "__main__":
-
-    pypath = "."
-    _ = lambda x: x
-    
-    db = FileHandler(None)
-
-    #p = PyFile(db, 5)
-    #sleep(0.1)
-
-    a = time()
-
-    #print db.addPackage("package", "folder" , 1)
-    
-    pack = db.db.addPackage("package", "folder", 1)
-    
-    updates = []
-    
-    
-    for x in range(0, 200):       
-        x = str(x)
-        db.db.addLink("http://somehost.com/hoster/file/download?file_id=" + x, x, "BasePlugin", pack)
-        updates.append(("new name" + x, 0, 3, "http://somehost.com/hoster/file/download?file_id=" + x))
-
-
-    for x in range(0, 100):
-        updates.append(("unimportant%s" % x, 0, 3, "a really long non existent url%s" % x))
-        
-    db.db.commit()
-
-    b = time()
-    print "adding 200 links, single sql execs, no commit", b-a
-    
-    print db.getCompleteData(1)
- 
-    c  = time()
-    
-
-    db.db.updateLinkInfo(updates)
-    
-    d = time()
-    
-    print "updates", d-c
-
-    print db.getCompleteData(1)
-    
-    
-    e = time()
-    
-    print "complete data", e-d
+        # fstatus = missing
+        self.c.execute("DELETE FROM files WHERE status == 1")
+
+    @queue
+    def purgeAll(self): # only used for debugging
+        self.c.execute("DELETE FROM packages")
+        self.c.execute("DELETE FROM files")
+        self.c.execute("DELETE FROM collector")
+
+
+FileMethods.register()
\ No newline at end of file
diff --git a/module/database/StatisticDatabase.py b/module/database/StatisticDatabase.py
new file mode 100644
index 000000000..10619eb5b
--- /dev/null
+++ b/module/database/StatisticDatabase.py
@@ -0,0 +1,13 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from module.database import DatabaseMethods, queue, async, inner
+
+# TODO
+
+class StatisticMethods(DatabaseMethods):
+    pass
+
+
+
+StatisticMethods.register()
\ No newline at end of file
diff --git a/module/database/StorageDatabase.py b/module/database/StorageDatabase.py
index 3ed29625f..ffaf51763 100644
--- a/module/database/StorageDatabase.py
+++ b/module/database/StorageDatabase.py
@@ -16,11 +16,10 @@
     @author: mkaay
 """
 
-from module.database import style
-from module.database import DatabaseBackend
+from module.database import DatabaseBackend, queue
 
 class StorageMethods():
-    @style.queue
+    @queue
     def setStorage(db, identifier, key, value):
         db.c.execute("SELECT id FROM storage WHERE identifier=? AND key=?", (identifier, key))
         if db.c.fetchone() is not None:
@@ -28,7 +27,7 @@ class StorageMethods():
         else:
             db.c.execute("INSERT INTO storage (identifier, key, value) VALUES (?, ?, ?)", (identifier, key, value))
     
-    @style.queue
+    @queue
     def getStorage(db, identifier, key=None):
         if key is not None:
             db.c.execute("SELECT value FROM storage WHERE identifier=? AND key=?", (identifier, key))
@@ -42,7 +41,7 @@ class StorageMethods():
                 d[row[0]] = row[1]
             return d
     
-    @style.queue
+    @queue
     def delStorage(db, identifier, key):
         db.c.execute("DELETE FROM storage WHERE identifier=? AND key=?", (identifier, key))
 
diff --git a/module/database/UserDatabase.py b/module/database/UserDatabase.py
index 0c781057d..0df94e0eb 100644
--- a/module/database/UserDatabase.py
+++ b/module/database/UserDatabase.py
@@ -1,63 +1,96 @@
 # -*- coding: utf-8 -*-
-"""
-    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.
+###############################################################################
+#   Copyright(c) 2008-2012 pyLoad Team
+#   http://www.pyload.org
+#
+#   This file is part of pyLoad.
+#   pyLoad is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU Affero General Public License as
+#   published by the Free Software Foundation, either version 3 of the
+#   License, or (at your option) any later version.
+#
+#   Subjected to the terms and conditions in LICENSE
+#
+#   @author: RaNaN
+###############################################################################
 
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, see <http://www.gnu.org/licenses/>.
+from hashlib import sha1
+from string import letters, digits
+from random import choice
 
-    @author: mkaay
-"""
+alphnum = letters+digits
 
-from hashlib import sha1
-import random
+from module.Api import UserData
 
-from DatabaseBackend import DatabaseBackend
-from DatabaseBackend import style
+from DatabaseBackend import DatabaseMethods, queue, async
 
-class UserMethods():
-    @style.queue
-    def checkAuth(db, user, password):
-        c = db.c
-        c.execute('SELECT id, name, password, role, permission, template, email FROM "users" WHERE name=?', (user, ))
-        r = c.fetchone()
-        if not r:
-            return {}
+def random_salt():
+    return "".join(choice(alphnum) for x in range(0,5))
 
-        salt = r[2][:5]
-        pw = r[2][5:]
-        h = sha1(salt + password)
-        if h.hexdigest() == pw:
-            return {"id": r[0], "name": r[1], "role": r[3],
-                    "permission": r[4], "template": r[5], "email": r[6]}
-        else:
-            return {}
+class UserMethods(DatabaseMethods):
 
-    @style.queue
-    def addUser(db, user, password):
-        salt = reduce(lambda x, y: x + y, [str(random.randint(0, 9)) for i in range(0, 5)])
+    @queue
+    def addUser(self, user, password):
+        salt = random_salt()
         h = sha1(salt + password)
         password = salt + h.hexdigest()
 
-        c = db.c
-        c.execute('SELECT name FROM users WHERE name=?', (user, ))
-        if c.fetchone() is not None:
-            c.execute('UPDATE users SET password=? WHERE name=?', (password, user))
+        self.c.execute('SELECT name FROM users WHERE name=?', (user, ))
+        if self.c.fetchone() is not None:
+            self.c.execute('UPDATE users SET password=? WHERE name=?', (password, user))
         else:
-            c.execute('INSERT INTO users (name, password) VALUES (?, ?)', (user, password))
+            self.c.execute('INSERT INTO users (name, password) VALUES (?, ?)', (user, password))
+
+    @queue
+    def getUserData(self, name=None, uid=None):
+        qry = ('SELECT uid, name, email, role, permission, folder, traffic, dllimit, dlquota, '
+               'hddquota, user, template FROM "users" WHERE ')
+
+        if name is not None:
+            self.c.execute(qry + "name=?", (name,))
+            r = self.c.fetchone()
+            if r:
+                return UserData(*r)
+
+        elif uid is not None:
+            self.c.execute(qry + "uid=?", (uid,))
+            r = self.c.fetchone()
+            if r:
+                return UserData(*r)
+
+        return None
+
+    @queue
+    def getAllUserData(self):
+        self.c.execute('SELECT uid, name, email, role, permission, folder, traffic, dllimit, dlquota, '
+                       'hddquota, user, template FROM "users"')
+        user = {}
+        for r in self.c:
+            user[r[0]] = UserData(*r)
+
+        return user
 
 
-    @style.queue
-    def changePassword(db, user, oldpw, newpw):
-        db.c.execute('SELECT id, name, password FROM users WHERE name=?', (user, ))
-        r = db.c.fetchone()
+    @queue
+    def checkAuth(self, user, password):
+        self.c.execute('SELECT uid, name, email, role, permission, folder, traffic, dllimit, dlquota, '
+                       'hddquota, user, template, password FROM "users" WHERE name=?', (user, ))
+        r = self.c.fetchone()
+        if not r:
+            return None
+        salt = r[-1][:5]
+        pw = r[-1][5:]
+        h = sha1(salt + password)
+        if h.hexdigest() == pw:
+            return UserData(*r[:-1])
+        else:
+            return None
+
+    @queue #TODO
+    def changePassword(self, user, oldpw, newpw):
+        self.c.execute('SELECT rowid, name, password FROM users WHERE name=?', (user, ))
+        r = self.c.fetchone()
         if not r:
             return False
 
@@ -65,44 +98,28 @@ class UserMethods():
         pw = r[2][5:]
         h = sha1(salt + oldpw)
         if h.hexdigest() == pw:
-            salt = reduce(lambda x, y: x + y, [str(random.randint(0, 9)) for i in range(0, 5)])
+            salt = random_salt()
             h = sha1(salt + newpw)
             password = salt + h.hexdigest()
 
-            db.c.execute("UPDATE users SET password=? WHERE name=?", (password, user))
+            self.c.execute("UPDATE users SET password=? WHERE name=?", (password, user))
             return True
 
         return False
 
+    @async
+    def setPermission(self, user, perms):
+        self.c.execute("UPDATE users SET permission=? WHERE name=?", (perms, user))
 
-    @style.async
-    def setPermission(db, user, perms):
-        db.c.execute("UPDATE users SET permission=? WHERE name=?", (perms, user))
-
-    @style.async
-    def setRole(db, user, role):
-        db.c.execute("UPDATE users SET role=? WHERE name=?", (role, user))
+    @async
+    def setRole(self, user, role):
+        self.c.execute("UPDATE users SET role=? WHERE name=?", (role, user))
 
+    # TODO update methods
 
-    @style.queue
-    def listUsers(db):
-        db.c.execute('SELECT name FROM users')
-        users = []
-        for row in db.c:
-            users.append(row[0])
-        return users
-
-    @style.queue
-    def getAllUserData(db):
-        db.c.execute("SELECT name, permission, role, template, email FROM users")
-        user = {}
-        for r in db.c:
-            user[r[0]] = {"permission": r[1], "role": r[2], "template": r[3], "email": r[4]}
-
-        return user
-
-    @style.queue
-    def removeUser(db, user):
-        db.c.execute('DELETE FROM users WHERE name=?', (user, ))
+    @async
+    def removeUser(self, uid=None):
+        # deletes user and all associated accounts
+        self.c.execute('DELETE FROM users WHERE user=?', (uid, ))
 
-DatabaseBackend.registerSub(UserMethods)
+UserMethods.register()
diff --git a/module/database/__init__.py b/module/database/__init__.py
index 545789c0c..d3f97fb53 100644
--- a/module/database/__init__.py
+++ b/module/database/__init__.py
@@ -1,6 +1,8 @@
-from DatabaseBackend import DatabaseBackend
-from DatabaseBackend import style
+from DatabaseBackend import DatabaseMethods, DatabaseBackend, queue, async, inner
 
-from FileDatabase import FileHandler
+from FileDatabase import FileMethods
 from UserDatabase import UserMethods
-from StorageDatabase import StorageMethods
\ No newline at end of file
+from StorageDatabase import StorageMethods
+from AccountDatabase import AccountMethods
+from ConfigDatabase import ConfigMethods
+from StatisticDatabase import StatisticMethods
\ No newline at end of file
diff --git a/module/datatypes/PyFile.py b/module/datatypes/PyFile.py
new file mode 100644
index 000000000..5f2be8769
--- /dev/null
+++ b/module/datatypes/PyFile.py
@@ -0,0 +1,268 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+###############################################################################
+#   Copyright(c) 2008-2012 pyLoad Team
+#   http://www.pyload.org
+#
+#   This file is part of pyLoad.
+#   pyLoad is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU Affero General Public License as
+#   published by the Free Software Foundation, either version 3 of the
+#   License, or (at your option) any later version.
+#
+#   Subjected to the terms and conditions in LICENSE
+#
+#   @author: RaNaN
+###############################################################################
+
+from time import sleep, time
+from ReadWriteLock import ReadWriteLock
+
+from module.Api import ProgressInfo, DownloadProgress, FileInfo, DownloadInfo, DownloadStatus
+from module.utils import lock, read_lock
+
+statusMap = {
+    "none": 0,
+    "offline": 1,
+    "online": 2,
+    "queued": 3,
+    "paused": 4,
+    "finished": 5,
+    "skipped": 6,
+    "failed": 7,
+    "starting": 8,
+    "waiting": 9,
+    "downloading": 10,
+    "temp. offline": 11,
+    "aborted": 12,
+    "decrypting": 13,
+    "processing": 14,
+    "custom": 15,
+    "unknown": 16,
+}
+
+
+class PyFile(object):
+    """
+    Represents a file object at runtime
+    """
+    __slots__ = ("m", "fid", "_name", "_size", "filestatus", "media", "added", "fileorder",
+                 "url", "pluginname", "hash", "status", "error", "packageid", "ownerid",
+                 "lock", "plugin", "waitUntil", "abort", "statusname",
+                 "reconnected", "pluginclass")
+
+    @staticmethod
+    def fromInfoData(m, info):
+        f = PyFile(m, info.fid, info.name, info.size, info.status, info.media, info.added, info.fileorder,
+                   "", "", "", DownloadStatus.NA, "", info.package, info.owner)
+        if info.download:
+            f.url = info.download.url
+            f.pluginname = info.download.plugin
+            f.hash = info.download.hash
+            f.status = info.download.status
+            f.error = info.download.error
+
+        return f
+
+    def __init__(self, manager, fid, name, size, filestatus, media, added, fileorder,
+                 url, pluginname, hash, status, error, package, owner):
+
+        self.m = manager
+
+        self.fid = int(fid)
+        self._name = name
+        self._size = size
+        self.filestatus = filestatus
+        self.media = media
+        self.added = added
+        self.fileorder = fileorder
+        self.url = url
+        self.pluginname = pluginname
+        self.hash = hash
+        self.status = status
+        self.error = error
+        self.ownerid = owner
+        self.packageid = package
+        # database information ends here
+
+        self.lock = ReadWriteLock()
+
+        self.plugin = None
+
+        self.waitUntil = 0 # time() + time to wait
+
+        # status attributes
+        self.abort = False
+        self.reconnected = False
+        self.statusname = None
+
+
+    @property
+    def id(self):
+        self.m.core.log.debug("Deprecated attr .id, use .fid instead")
+        return self.fid
+
+    def setSize(self, value):
+        self._size = int(value)
+
+    # will convert all sizes to ints
+    size = property(lambda self: self._size, setSize)
+
+    def getName(self):
+        try:
+            if self.plugin.req.name:
+                return self.plugin.req.name
+            else:
+                return self._name
+        except:
+            return self._name
+
+    def setName(self, name):
+        """ Only set unicode or utf8 strings as name """
+        if type(name) == str:
+            name = name.decode("utf8")
+
+        self._name = name
+
+    name = property(getName, setName)
+
+    def __repr__(self):
+        return "<PyFile %s: %s@%s>" % (self.id, self.name, self.pluginname)
+
+    @lock
+    def initPlugin(self):
+        """ inits plugin instance """
+        if not self.plugin:
+            self.pluginclass = self.m.core.pluginManager.getPlugin(self.pluginname)
+            self.plugin = self.pluginclass(self)
+
+    @read_lock
+    def hasPlugin(self):
+        """Thread safe way to determine this file has initialized plugin attribute"""
+        return hasattr(self, "plugin") and self.plugin
+
+    def package(self):
+        """ return package instance"""
+        return self.m.getPackage(self.packageid)
+
+    def setStatus(self, status):
+        self.status = statusMap[status]
+        # needs to sync so status is written to database
+        self.sync()
+
+    def setCustomStatus(self, msg, status="processing"):
+        self.statusname = msg
+        self.setStatus(status)
+
+    def getStatusName(self):
+        if self.status not in (13, 14) or not self.statusname:
+            return self.m.statusMsg[self.status]
+        else:
+            return self.statusname
+
+    def hasStatus(self, status):
+        return statusMap[status] == self.status
+
+    def sync(self):
+        """sync PyFile instance with database"""
+        self.m.updateFile(self)
+
+    @lock
+    def release(self):
+        """sync and remove from cache"""
+        if hasattr(self, "plugin") and self.plugin:
+            self.plugin.clean()
+            del self.plugin
+
+        self.m.releaseFile(self.fid)
+
+
+    def toInfoData(self):
+        return FileInfo(self.fid, self.getName(), self.packageid, self.ownerid, self.getSize(), self.filestatus,
+                        self.media, self.added, self.fileorder, DownloadInfo(
+                self.url, self.pluginname, self.hash, self.status, self.getStatusName(), self.error
+            )
+        )
+
+    def getPath(self):
+        pass
+
+    def move(self, pid):
+        pass
+
+    @read_lock
+    def abortDownload(self):
+        """abort pyfile if possible"""
+        # TODO: abort timeout, currently dead locks
+        while self.id in self.m.core.threadManager.processingIds():
+            self.abort = True
+            if self.plugin and self.plugin.req:
+                self.plugin.req.abortDownloads()
+            sleep(0.1)
+
+        self.abort = False
+        if self.plugin and self.plugin.req:
+            self.plugin.req.abortDownloads()
+
+        self.release()
+
+    def finishIfDone(self):
+        """set status to finish and release file if every thread is finished with it"""
+
+        if self.id in self.m.core.threadManager.processingIds():
+            return False
+
+        self.setStatus("finished")
+        self.release()
+        self.m.checkAllLinksFinished()
+        return True
+
+    def checkIfProcessed(self):
+        self.m.checkAllLinksProcessed(self.id)
+
+    def getSpeed(self):
+        """ calculates speed """
+        try:
+            return self.plugin.req.speed
+        except:
+            return 0
+
+    def getETA(self):
+        """ gets established time of arrival / or waiting time"""
+        try:
+            if self.status == DownloadStatus.Waiting:
+                return self.waitUntil - time()
+
+            return self.getBytesLeft() / self.getSpeed()
+        except:
+            return 0
+
+    def getBytesArrived(self):
+        """ gets bytes arrived """
+        try:
+            return self.plugin.req.arrived
+        except:
+            return 0
+
+    def getBytesLeft(self):
+        """ gets bytes left """
+        try:
+            return self.plugin.req.size - self.plugin.req.arrived
+        except:
+            return 0
+
+    def getSize(self):
+        """ get size of download """
+        try:
+            if self.plugin.req.size:
+                return self.plugin.req.size
+            else:
+                return self.size
+        except:
+            return self.size
+
+    def getProgressInfo(self):
+        return ProgressInfo(self.pluginname, self.name, self.getStatusName(), self.getETA(),
+                            self.getBytesArrived(), self.getSize(),
+                            DownloadProgress(self.fid, self.packageid, self.getSpeed(), self.status))
diff --git a/module/datatypes/PyPackage.py b/module/datatypes/PyPackage.py
new file mode 100644
index 000000000..6ba37ee12
--- /dev/null
+++ b/module/datatypes/PyPackage.py
@@ -0,0 +1,115 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+###############################################################################
+#   Copyright(c) 2008-2012 pyLoad Team
+#   http://www.pyload.org
+#
+#   This file is part of pyLoad.
+#   pyLoad is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU Affero General Public License as
+#   published by the Free Software Foundation, either version 3 of the
+#   License, or (at your option) any later version.
+#
+#   Subjected to the terms and conditions in LICENSE
+#
+#   @author: RaNaN
+###############################################################################
+
+from time import time
+
+from module.Api import PackageInfo, PackageStatus
+from module.utils.fs import join
+
+class PyPackage:
+    """
+    Represents a package object at runtime
+    """
+
+    @staticmethod
+    def fromInfoData(m, info):
+        return PyPackage(m, info.pid, info.name, info.folder, info.root, info.owner,
+            info.site, info.comment, info.password, info.added, info.tags, info.status, info.shared, info.packageorder)
+
+    def __init__(self, manager, pid, name, folder, root, owner, site, comment, password, added, tags, status,
+                 shared, packageorder):
+        self.m = manager
+
+        self.pid = pid
+        self.name = name
+        self.folder = folder
+        self.root = root
+        self.ownerid = owner
+        self.site = site
+        self.comment = comment
+        self.password = password
+        self.added = added
+        self.tags = tags
+        self.status = status
+        self.shared = shared
+        self.packageorder = packageorder
+        self.timestamp = time()
+
+        #: Finish event already fired
+        self.setFinished = False
+
+    @property
+    def id(self):
+        self.m.core.log.debug("Deprecated package attr .id, use .pid instead")
+        return self.pid
+
+    def isStale(self):
+        return self.timestamp + 30 * 60 > time()
+
+    def toInfoData(self):
+        return PackageInfo(self.pid, self.name, self.folder, self.root, self.ownerid, self.site,
+            self.comment, self.password, self.added, self.tags, self.status, self.shared, self.packageorder
+        )
+
+    def getChildren(self):
+        """get information about contained links"""
+        return self.m.getPackageData(self.pid)["links"]
+
+    def getPath(self, name=""):
+        self.timestamp = time()
+        return join(self.m.getPackage(self.root).getPath(), self.folder, name)
+
+    def sync(self):
+        """sync with db"""
+        self.m.updatePackage(self)
+
+    def release(self):
+        """sync and delete from cache"""
+        self.sync()
+        self.m.releasePackage(self.id)
+
+    def delete(self):
+        self.m.deletePackage(self.id)
+
+    def deleteIfEmpty(self):
+        """  True if deleted  """
+        if not len(self.getChildren()):
+            self.delete()
+            return True
+        return False
+
+    def notifyChange(self):
+        self.m.core.eventManager.dispatchEvent("packageUpdated", self.id)
+
+
+class RootPackage(PyPackage):
+    def __init__(self, m, owner):
+        PyPackage.__init__(self, m, -1, "root", "", owner, -2, "", "", "", 0, [], PackageStatus.Ok, False, 0)
+
+    def getPath(self, name=""):
+        return join(self.m.core.config["general"]["download_folder"], name)
+
+    # no database operations
+    def sync(self):
+        pass
+
+    def delete(self):
+        pass
+
+    def release(self):
+        pass
\ No newline at end of file
diff --git a/module/datatypes/User.py b/module/datatypes/User.py
new file mode 100644
index 000000000..da7fb90bf
--- /dev/null
+++ b/module/datatypes/User.py
@@ -0,0 +1,63 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+###############################################################################
+#   Copyright(c) 2008-2012 pyLoad Team
+#   http://www.pyload.org
+#
+#   This file is part of pyLoad.
+#   pyLoad is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU Affero General Public License as
+#   published by the Free Software Foundation, either version 3 of the
+#   License, or (at your option) any later version.
+#
+#   Subjected to the terms and conditions in LICENSE
+#
+#   @author: RaNaN
+###############################################################################
+
+
+from module.Api import UserData, Permission, Role
+from module.utils import bits_set
+
+#TODO: activate user
+#noinspection PyUnresolvedReferences
+class User(UserData):
+
+    @staticmethod
+    def fromUserData(api, user):
+        return User(api, user.uid, user.name, user.email, user.role, user.permission, user.folder,
+            user.traffic, user.dllimit, user.dlquota, user.hddquota, user.user, user.templateName)
+
+    def __init__(self, api,  *args, **kwargs):
+        UserData.__init__(self, *args, **kwargs)
+        self.api = api
+
+
+    def toUserData(self):
+        # TODO
+        return UserData()
+
+    def hasPermission(self, perms):
+        """  Accepts permission bit or name  """
+        if isinstance(perms, basestring) and hasattr(Permission, perms):
+            perms = getattr(Role, perms)
+
+        return bits_set(perms, self.permission)
+
+    def hasRole(self, role):
+        if isinstance(role, basestring) and hasattr(Role, role):
+            role = getattr(Role, role)
+
+        return self.role == role
+
+    def isAdmin(self):
+        return self.hasRole(Role.Admin)
+
+    @property
+    def primary(self):
+        """ Primary user id, Internal user handle used for most operations
+        Secondary user account share id with primary user. Only Admins have no primary id. """
+        if self.hasRole(Role.Admin):
+            return None
+        return self.user if self.user else self.uid
\ No newline at end of file
diff --git a/module/plugins/captcha/__init__.py b/module/datatypes/__init__.py
index e69de29bb..e69de29bb 100644
--- a/module/plugins/captcha/__init__.py
+++ b/module/datatypes/__init__.py
diff --git a/module/debug.py b/module/debug.py
deleted file mode 100644
index 8d1ddd3d0..000000000
--- a/module/debug.py
+++ /dev/null
@@ -1,95 +0,0 @@
-#!/usr/bin/env python
-#coding:utf-8
-
-import re
-import InitHomeDir
-from os import listdir
-
-class Wrapper(object):
-	pass
-
-def filter_info(line):
-	if "object at 0x" in line:
-		return False
-	elif " at line " in line:
-		return False
-	elif " <DownloadThread(" in line:
-		return False
-	elif "<class '" in line:
-		return False
-	elif "PyFile " in line:
-		return False
-	elif " <module '" in line:
-		return False
-	
-	else:
-		return True
-	
-def appendName(lines, name):
-	test = re.compile("^[a-zA-z0-9]+ = ")
-	
-	for i, line in enumerate(lines):
-		if test.match(line):
-			lines[i] = name+"."+line
-			
-	return lines
-
-def initReport():
-	reports = []
-	for f in listdir("."):
-		if f.startswith("debug_"):
-			reports.append(f)
-		
-	for i, f in enumerate(reports):
-		print "%s. %s" % (i,f) 
-	
-	choice = raw_input("Choose Report: ")
-	
-	report = reports[int(choice)]
-	
-	f = open(report, "rb")
-
-	content = f.readlines()
-	content = [x.strip() for x in content if x.strip()]
-	
-	frame = Wrapper()
-	plugin = Wrapper()
-	pyfile = Wrapper()
-	
-	frame_c = [] 
-	plugin_c = []
-	pyfile_c = []
-	
-	dest = None
-	
-	for line in  content:
-		if line == "FRAMESTACK:":
-			dest = frame_c
-			continue
-		elif line == "PLUGIN OBJECT DUMP:":
-			dest = plugin_c
-			continue
-		elif line == "PYFILE OBJECT DUMP:":
-			dest = pyfile_c
-			continue
-		elif line == "CONFIG:":
-			dest = None
-	
-		if dest is not None:
-			dest.append(line)
-			
-			
-	frame_c = filter(filter_info, frame_c)
-	plugin_c = filter(filter_info, plugin_c)
-	pyfile_c = filter(filter_info, pyfile_c)
-	
-	frame_c = appendName(frame_c, "frame")
-	plugin_c = appendName(plugin_c, "plugin")
-	pyfile_c = appendName(pyfile_c, "pyfile")
-		
-	exec("\n".join(frame_c+plugin_c+pyfile_c) )
-	
-	return frame, plugin, pyfile
-	
-if __name__=='__main__':
-	print "No main method, use this module with your python shell"
\ No newline at end of file
diff --git a/module/gui/AccountEdit.py b/module/gui/AccountEdit.py
deleted file mode 100644
index b22cfc49f..000000000
--- a/module/gui/AccountEdit.py
+++ /dev/null
@@ -1,104 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    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/>.
-    
-    @author: mkaay
-"""
-
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
-
-from os.path import join
-
-class AccountEdit(QWidget):
-    """
-        account editor widget
-    """
-    
-    def __init__(self):
-        QMainWindow.__init__(self)
-
-        self.setWindowTitle(_("Edit account"))
-        self.setWindowIcon(QIcon(join(pypath, "icons","logo.png")))
-        
-        self.setLayout(QGridLayout())
-        l = self.layout()
-        
-        typeLabel = QLabel(_("Type"))
-        loginLabel = QLabel(_("Login"))
-        passwordLabel = QLabel(_("New password"))
-        changePw = QCheckBox()
-        changePw.setChecked(False)
-        self.changePw = changePw
-        password = QLineEdit()
-        password.setEnabled(False)
-        password.setEchoMode(QLineEdit.Password)
-        self.password = password
-        login = QLineEdit()
-        self.login = login
-        acctype = QComboBox()
-        self.acctype = acctype
-        
-        save = QPushButton(_("Save"))
-        
-        self.connect(changePw, SIGNAL("toggled(bool)"), password, SLOT("setEnabled(bool)"))
-        
-        l.addWidget(save, 3, 0, 1, 3)
-        l.addWidget(acctype, 0, 1, 1, 2)
-        l.addWidget(login, 1, 1, 1, 2)
-        l.addWidget(password, 2, 2)
-        l.addWidget(changePw, 2, 1)
-        l.addWidget(passwordLabel, 2, 0)
-        l.addWidget(loginLabel, 1, 0)
-        l.addWidget(typeLabel, 0, 0)
-        
-        self.connect(save, SIGNAL("clicked()"), self.slotSave)
-    
-    def slotSave(self):
-        """
-            save entered data
-        """
-        data = {"login": str(self.login.text()), "acctype": str(self.acctype.currentText()), "password": False}
-        if self.changePw.isChecked():
-            data["password"] = str(self.password.text())
-        self.emit(SIGNAL("done"), data)
-    
-    @staticmethod
-    def newAccount(types):
-        """
-            create empty editor instance
-        """
-        w = AccountEdit()
-        w.setWindowTitle(_("Create account"))
-        
-        w.changePw.setChecked(True)
-        w.password.setEnabled(True)
-        
-        w.acctype.addItems(types)
-        
-        return w
-    
-    @staticmethod
-    def editAccount(types, base):
-        """
-            create editor instance with given data
-        """
-        w = AccountEdit()
-        
-        w.acctype.addItems(types)
-        w.acctype.setCurrentIndex(types.index(base["type"]))
-        
-        w.login.setText(base["login"])
-        
-        return w
diff --git a/module/gui/Accounts.py b/module/gui/Accounts.py
deleted file mode 100644
index 8db04dfa9..000000000
--- a/module/gui/Accounts.py
+++ /dev/null
@@ -1,213 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    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/>.
-    
-    @author: mkaay
-"""
-
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
-
-from time import strftime, gmtime
-
-class AccountModel(QAbstractItemModel):
-    """
-        model for account view
-    """
-    
-    def __init__(self, view, connector):
-        QAbstractItemModel.__init__(self)
-        self.connector = connector
-        self.view = view
-        self._data = []
-        self.cols = 4
-        self.mutex = QMutex()
-    
-    def reloadData(self, force=False):
-        """
-            reload account list
-        """
-        accounts = self.connector.proxy.getAccounts(False)
-
-        if self._data == accounts:
-            return
-        
-        if len(self._data) > 0:        
-            self.beginRemoveRows(QModelIndex(), 0, len(self._data)-1)
-            self._data = []
-            self.endRemoveRows()
-            
-        if len(accounts) > 0:
-            self.beginInsertRows(QModelIndex(), 0, len(accounts)-1)
-            self._data = accounts
-            self.endInsertRows()
-    
-    def toData(self, index):
-        """
-            return index pointer
-        """
-        return index.internalPointer()
-    
-    def data(self, index, role=Qt.DisplayRole):
-        """
-            return cell data
-        """
-        if not index.isValid():
-            return QVariant()
-        if role == Qt.DisplayRole:
-            if index.column() == 0:
-                return QVariant(self.toData(index).type)
-            elif index.column() == 1:
-                return QVariant(self.toData(index).login)
-            elif index.column() == 2:
-                if not self.toData(index).valid:
-                    return QVariant(_("not valid"))
-                if not self.toData(index).validuntil:
-                    return QVariant(_("n/a"))
-                until = int(self.toData(index).validuntil)
-                if until > 0:
-                    fmtime = strftime(_("%a, %d %b %Y %H:%M"), gmtime(until))
-                    return QVariant(fmtime)
-                else:
-                    return QVariant(_("unlimited"))
-        #elif role == Qt.EditRole:
-        #    if index.column() == 0:
-        #        return QVariant(index.internalPointer().data["name"])
-        return QVariant()
-        
-    def index(self, row, column, parent=QModelIndex()):
-        """
-            create index with data pointer
-        """
-        if parent == QModelIndex() and len(self._data) > row:
-            pointer = self._data[row]
-            index = self.createIndex(row, column, pointer)
-        elif parent.isValid():
-            pointer = parent.internalPointer().children[row]
-            index = self.createIndex(row, column, pointer)
-        else:
-            index = QModelIndex()
-        return index
-    
-    def parent(self, index):
-        """
-            no parents, everything on top level
-        """
-        return QModelIndex()
-    
-    def rowCount(self, parent=QModelIndex()):
-        """
-            account count
-        """
-        if parent == QModelIndex():
-            return len(self._data)
-        return 0
-    
-    def columnCount(self, parent=QModelIndex()):
-        return self.cols
-    
-    def hasChildren(self, parent=QModelIndex()):
-        """
-            everything on top level
-        """
-        if parent == QModelIndex():
-            return True
-        else:
-            return False
-    
-    def canFetchMore(self, parent):
-        return False
-    
-    def headerData(self, section, orientation, role=Qt.DisplayRole):
-        """
-            returns column heading
-        """
-        if orientation == Qt.Horizontal and role == Qt.DisplayRole:
-            if section == 0:
-                return QVariant(_("Type"))
-            elif section == 1:
-                return QVariant(_("Login"))
-            elif section == 2:
-                return QVariant(_("Valid until"))
-            elif section == 3:
-                return QVariant(_("Traffic left"))
-        return QVariant()
-    
-    def flags(self, index):
-        """
-            cell flags
-        """
-        return Qt.ItemIsSelectable | Qt.ItemIsEnabled
-    
-class AccountView(QTreeView):
-    """
-        view component for accounts
-    """
-    
-    def __init__(self, connector):
-        QTreeView.__init__(self)
-        self.setModel(AccountModel(self, connector))
-        
-        self.setColumnWidth(0, 150)
-        self.setColumnWidth(1, 150)
-        self.setColumnWidth(2, 150)
-        self.setColumnWidth(3, 150)
-        
-        self.setEditTriggers(QAbstractItemView.NoEditTriggers)
-        
-        self.delegate = AccountDelegate(self, self.model())
-        self.setItemDelegateForColumn(3, self.delegate)
-
-class AccountDelegate(QItemDelegate):
-    """
-        used to display a progressbar for the traffic in the traffic cell
-    """
-    
-    def __init__(self, parent, model):
-        QItemDelegate.__init__(self, parent)
-        self.model = model
-
-    def paint(self, painter, option, index):
-        """
-            paint the progressbar
-        """
-        if not index.isValid():
-            return
-        if index.column() == 3:
-            data = self.model.toData(index)
-            opts = QStyleOptionProgressBarV2()
-            opts.minimum = 0
-            if data.trafficleft:
-                if data.trafficleft == -1 or data.trafficleft is None:
-                    opts.maximum = opts.progress = 1
-                else:
-                    opts.maximum = opts.progress = data.trafficleft
-            if data.maxtraffic:
-                opts.maximum = data.maxtraffic
-            
-            opts.rect = option.rect
-            opts.rect.setRight(option.rect.right()-1)
-            opts.rect.setHeight(option.rect.height()-1)
-            opts.textVisible = True
-            opts.textAlignment = Qt.AlignCenter
-            if data.trafficleft and data.trafficleft == -1:
-                opts.text = QString(_("unlimited"))
-            elif data.trafficleft is None:
-                opts.text = QString(_("n/a"))
-            else:
-                opts.text = QString.number(round(float(opts.progress)/1024/1024, 2)) + " GB"
-            QApplication.style().drawControl(QStyle.CE_ProgressBar, opts, painter)
-            return
-        QItemDelegate.paint(self, painter, option, index)
-
diff --git a/module/gui/CNLServer.py b/module/gui/CNLServer.py
deleted file mode 100644
index 5ecac8277..000000000
--- a/module/gui/CNLServer.py
+++ /dev/null
@@ -1,226 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    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/>.
-
-    @author: RaNaN
-"""
-import re
-from BaseHTTPServer import HTTPServer, BaseHTTPRequestHandler
-from threading import Thread
-from cgi import FieldStorage
-from os.path import abspath, dirname, join
-from urllib import unquote
-from base64 import standard_b64decode
-from binascii import unhexlify
-
-try:
-    from Crypto.Cipher import AES
-except:
-    pass
-
-try:
-    from module.common import JsEngine
-except ImportError:
-    import sys
-    sys.path.append(join(abspath(dirname(__file__)), "..", ".."))
-    from module.common import JsEngine
-
-js = JsEngine.JsEngine()
-core = None
-
-class CNLServer(Thread):
-    def __init__(self):
-        Thread.__init__(self)
-        self.setDaemon(True)
-        
-        self.stop = False
-        self.stopped = False
-
-    def run(self):
-        server_address = ('127.0.0.1', 9666)
-        try:
-            httpd = HTTPServer(server_address, CNLHandler)
-        except:
-            self.stopped = True
-            return
-        
-        self.stopped = False
-        while self.keep_running():
-            httpd.handle_request()
-        self.stopped = True
-
-    def keep_running(self):
-        return not self.stop
-
-
-class CNLHandler(BaseHTTPRequestHandler):
-
-    #def log_message(self, *args):
-    #    pass
-
-    def add_package(self, name, urls, queue=0):
-        print "name", name
-        print "urls", urls
-        print "queue", queue
-
-    def get_post(self, name, default=""):
-        if name in self.post:
-            return self.post[name]
-        else:
-            return default
-
-    def start_response(self, string):
-
-        self.send_response(200)
-
-        self.send_header("Content-Length", len(string))
-        self.send_header("Content-Language", "de")
-        self.send_header("Vary", "Accept-Language, Cookie")
-        self.send_header("Cache-Control", "no-cache, must-revalidate")
-        self.send_header("Content-type", "text/html")
-        self.end_headers()
-
-    def do_GET(self):
-        path = self.path.strip("/").lower()
-        #self.wfile.write(path+"\n")
-
-        self.map = [ (r"add$", self.add),
-                (r"addcrypted$", self.addcrypted),
-                (r"addcrypted2$", self.addcrypted2),
-                (r"flashgot", self.flashgot),
-                (r"crossdomain\.xml", self.crossdomain),
-                (r"checkSupportForUrl", self.checksupport),
-                (r"jdcheck.js", self.jdcheck),
-                (r"", self.flash) ]
-
-        func = None
-        for r, f in self.map:
-            if re.match(r"(flash(got)?/?)?"+r, path):
-                func = f
-                break
-
-        if func:
-            try:
-                resp = func()
-                if not resp: resp = "success"
-                resp += "\r\n"
-                self.start_response(resp)
-                self.wfile.write(resp)
-            except Exception,e :
-                self.send_error(500, str(e))
-        else:
-            self.send_error(404, "Not Found")
-
-    def do_POST(self):
-        form = FieldStorage(
-                fp=self.rfile,
-                headers=self.headers,
-                environ={'REQUEST_METHOD':'POST',
-                         'CONTENT_TYPE':self.headers['Content-Type'],
-                         })
-
-        self.post = {}
-        for name in form.keys():
-            self.post[name] = form[name].value
-
-        return self.do_GET()
-
-    def flash(self):
-        return "JDownloader"
-
-    def add(self):
-        package = self.get_post('referer', 'ClickAndLoad Package')
-        urls = filter(lambda x: x != "", self.get_post('urls').split("\n"))
-
-        self.add_package(package, urls, 0)
-
-    def addcrypted(self):
-        package = self.get_post('referer', 'ClickAndLoad Package')
-        dlc = self.get_post('crypted').replace(" ", "+")
-
-        core.upload_container(package, dlc)
-
-    def addcrypted2(self):
-        package = self.get_post("source", "ClickAndLoad Package")
-        crypted = self.get_post("crypted")
-        jk = self.get_post("jk")
-
-        crypted = standard_b64decode(unquote(crypted.replace(" ", "+")))
-        jk = "%s f()" % jk
-        jk = js.eval(jk)
-        Key = unhexlify(jk)
-        IV = Key
-
-        obj = AES.new(Key, AES.MODE_CBC, IV)
-        result = obj.decrypt(crypted).replace("\x00", "").replace("\r","").split("\n")
-
-        result = filter(lambda x: x != "", result)
-
-        self.add_package(package, result, 0)
-
-
-    def flashgot(self):
-        autostart = int(self.get_post('autostart', 0))
-        package = self.get_post('package', "FlashGot")
-        urls = filter(lambda x: x != "", self.get_post('urls').split("\n"))
-
-        self.add_package(package, urls, autostart)
-
-    def crossdomain(self):
-        rep = "<?xml version=\"1.0\"?>\n"
-        rep += "<!DOCTYPE cross-domain-policy SYSTEM \"http://www.macromedia.com/xml/dtds/cross-domain-policy.dtd\">\n"
-        rep += "<cross-domain-policy>\n"
-        rep += "<allow-access-from domain=\"*\" />\n"
-        rep += "</cross-domain-policy>"
-        return rep
-
-    def checksupport(self):
-        pass
-
-    def jdcheck(self):
-        rep = "jdownloader=true;\n"
-        rep += "var version='10629';\n"
-        return rep
-
-
-if __name__ == "__main__":
-    import xmlrpclib
-    from module import InitHomeDir
-    from module.ConfigParser import ConfigParser
-
-    config = ConfigParser()
-
-    ssl = ""
-    if config.get("ssl", "activated"):
-        ssl = "s"
-
-    server_url = "http%s://%s:%s@%s:%s/" % (
-                                        ssl,
-                                        config.username,
-                                        config.password,
-                                        config.get("remote", "listenaddr"),
-                                        config.get("remote", "port")
-                                        )
-
-    core = xmlrpclib.ServerProxy(server_url, allow_none=True)
-
-    s = CNLServer()
-    s.start()
-    while not s.stopped:
-        try:
-            s.join(1)
-        except KeyboardInterrupt:
-            s.stop = True
-            s.stopped = True
-            print "quiting.."
diff --git a/module/gui/CaptchaDock.py b/module/gui/CaptchaDock.py
deleted file mode 100644
index b88cb53ca..000000000
--- a/module/gui/CaptchaDock.py
+++ /dev/null
@@ -1,94 +0,0 @@
-# -*- coding: utf-8 -*-
-
-"""
-    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/>.
-    
-    @author: mkaay
-"""
-
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
-
-class CaptchaDock(QDockWidget):
-    """
-        dock widget for captcha input
-    """
-    
-    def __init__(self):
-        QDockWidget.__init__(self, _("Captcha"))
-        self.setObjectName("Captcha Dock")
-        self.widget = CaptchaDockWidget(self)
-        self.setWidget(self.widget)
-        self.setAllowedAreas(Qt.BottomDockWidgetArea)
-        self.setFeatures(QDockWidget.NoDockWidgetFeatures)
-        self.hide()
-        self.processing = False
-        self.currentID = None
-        self.connect(self, SIGNAL("setTask"), self.setTask)
-    
-    def isFree(self):
-        return not self.processing
-    
-    def setTask(self, tid, img, imgType):
-        self.processing = True
-        data = QByteArray(img)
-        self.currentID = tid
-        self.widget.emit(SIGNAL("setImage"), data)
-        self.widget.input.setText("")
-        self.show()
-
-class CaptchaDockWidget(QWidget):
-    """
-        widget for the input widgets
-    """
-    
-    def __init__(self, dock):
-        QWidget.__init__(self)
-        self.dock = dock
-        self.setLayout(QHBoxLayout())
-        layout = self.layout()
-        
-        imgLabel = QLabel()
-        captchaInput = QLineEdit()
-        okayButton = QPushButton(_("OK"))
-        cancelButton = QPushButton(_("Cancel"))
-        
-        layout.addStretch()
-        layout.addWidget(imgLabel)
-        layout.addWidget(captchaInput)
-        layout.addWidget(okayButton)
-        layout.addWidget(cancelButton)
-        layout.addStretch()
-        
-        self.input = captchaInput
-        
-        self.connect(okayButton, SIGNAL("clicked()"), self.slotSubmit)
-        self.connect(captchaInput, SIGNAL("returnPressed()"), self.slotSubmit)
-        self.connect(self, SIGNAL("setImage"), self.setImg)
-        self.connect(self, SIGNAL("setPixmap(const QPixmap &)"), imgLabel, SLOT("setPixmap(const QPixmap &)"))
-    
-    def setImg(self, data):
-        pixmap = QPixmap()
-        pixmap.loadFromData(data)
-        self.emit(SIGNAL("setPixmap(const QPixmap &)"), pixmap)
-        self.input.setFocus(Qt.OtherFocusReason)
-    
-    def slotSubmit(self):
-        text = self.input.text()
-        tid = self.dock.currentID
-        self.dock.currentID = None
-        self.dock.emit(SIGNAL("done"), tid, str(text))
-        self.dock.hide()
-        self.dock.processing = False
-
diff --git a/module/gui/Collector.py b/module/gui/Collector.py
deleted file mode 100644
index 3ec4262f1..000000000
--- a/module/gui/Collector.py
+++ /dev/null
@@ -1,407 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    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/>.
-    
-    @author: mkaay
-"""
-
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
-
-from module.PyFile import statusMap
-from module.utils import formatSize
-
-from module.remote.thriftbackend.ThriftClient import Destination, FileDoesNotExists, ElementType
-
-statusMapReverse = dict((v,k) for k, v in statusMap.iteritems())
-
-translatedStatusMap = {} # -> CollectorModel.__init__
-
-class CollectorModel(QAbstractItemModel):
-    """
-        model for the collector view
-    """
-    
-    def __init__(self, view, connector):
-        QAbstractItemModel.__init__(self)
-        self.connector = connector
-        self.view = view
-        self._data = []
-        self.cols = 4
-        self.interval = 1
-        self.mutex = QMutex()
-        
-        global translatedStatusMap # workaround because i18n is not running at import time
-        translatedStatusMap = {
-            "finished":    _("finished"),
-            "offline":     _("offline"),
-            "online":      _("online"),
-            "queued":      _("queued"),
-            "skipped":    _("skipped"),
-            "waiting":     _("waiting"),
-            "temp. offline": _("temp. offline"),
-            "starting":    _("starting"),
-            "failed":      _("failed"),
-            "aborted":     _("aborted"),
-            "decrypting":  _("decrypting"),
-            "custom":      _("custom"),
-            "downloading": _("downloading"),
-            "processing":  _("processing")
-        }
-    
-    def translateStatus(self, string):
-        """
-            used to convert to locale specific status
-        """
-        return translatedStatusMap[string]
-    
-    def addEvent(self, event):
-        """
-            called from main loop, pass events to the correct methods
-        """
-        QMutexLocker(self.mutex)
-        if event.eventname == "reload":
-            self.fullReload()
-        elif event.eventname == "remove":
-            self.removeEvent(event)
-        elif event.eventname == "insert":
-            self.insertEvent(event)
-        elif event.eventname == "update":
-            self.updateEvent(event)
-    
-    def fullReload(self):
-        """
-            reload whole model, used at startup to load initial data
-        """
-        self._data = []
-        order = self.connector.getPackageOrder(Destination.Collector)
-        self.beginInsertRows(QModelIndex(), 0, len(order.values()))
-        for position, pid in order.iteritems():
-            pack = self.connector.getPackageData(pid)
-            package = Package(pack)
-            self._data.append(package)
-        self._data = sorted(self._data, key=lambda p: p.data["order"])
-        self.endInsertRows()
-    
-    def removeEvent(self, event):
-        """
-            remove an element from model
-        """
-        if event.type == ElementType.File:
-            for p, package in enumerate(self._data):
-                for k, child in enumerate(package.children):
-                    if child.id == event.id:
-                        self.beginRemoveRows(self.index(p, 0), k, k)
-                        del package.children[k]
-                        self.endRemoveRows()
-                        break
-        else:
-            for k, package in enumerate(self._data):
-                if package.id == event.id:
-                    self.beginRemoveRows(QModelIndex(), k, k)
-                    del self._data[k]
-                    self.endRemoveRows()
-                    break
-    
-    def insertEvent(self, event):
-        """
-            inserts a new element in the model
-        """
-        if event.type == ElementType.File:
-            try:
-                info = self.connector.getFileData(event.id)
-            except FileDoesNotExists:
-                return
-            
-            for k, package in enumerate(self._data):
-                if package.id == info.package:
-                    if package.getChild(info.fid):
-                        self.updateEvent(event)
-                        break
-                    self.beginInsertRows(self.index(k, 0), info.order, info.order)
-                    package.addChild(info)
-                    self.endInsertRows()
-                    break
-        else:
-            data = self.connector.getPackageData(event.id)
-            package = Package(data)
-            self.beginInsertRows(QModelIndex(), data.order, data.order)
-            self._data.insert(data.order, package)
-            self.endInsertRows()
-    
-    def updateEvent(self, event):
-        """
-            update an element in the model
-        """
-        if event.type == ElementType.File:
-            try:
-                info = self.connector.proxy.getFileData(event.id)
-            except FileDoesNotExists:
-                return
-            for p, package in enumerate(self._data):
-                if package.id == info.packageID:
-                    for k, child in enumerate(package.children):
-                        if child.id == event.id:
-                            child.update(info)
-                            if not info.status == 12:
-                                child.data["downloading"] = None
-                            self.emit(SIGNAL("dataChanged(const QModelIndex &, const QModelIndex &)"), self.index(k, 0, self.index(p, 0)), self.index(k, self.cols, self.index(p, self.cols)))
-                    break
-        else:
-            data = self.connector.getPackageData(event.id)
-            if not data:
-                return
-            for p, package in enumerate(self._data):
-                if package.id == event.id:
-                    package.update(data)
-                    self.emit(SIGNAL("dataChanged(const QModelIndex &, const QModelIndex &)"), self.index(p, 0), self.index(p, self.cols))
-                    break
-    
-    def data(self, index, role=Qt.DisplayRole):
-        """
-            return cell data
-        """
-        if not index.isValid():
-            return QVariant()
-        if role == Qt.DisplayRole:
-            if index.column() == 0:
-                return QVariant(index.internalPointer().data["name"])
-            elif index.column() == 1:
-                item = index.internalPointer()
-                plugins = []
-                if isinstance(item, Package):
-                    for child in item.children:
-                        if not child.data["plugin"] in plugins:
-                            plugins.append(child.data["plugin"])
-                else:
-                    plugins.append(item.data["plugin"])
-                return QVariant(", ".join(plugins))
-            elif index.column() == 2:
-                item = index.internalPointer()
-                status = 0
-                if isinstance(item, Package):
-                    for child in item.children:
-                        if child.data["status"] > status:
-                            status = child.data["status"]
-                else:
-                    status = item.data["status"]
-                return QVariant(self.translateStatus(statusMapReverse[status]))
-            elif index.column() == 3:
-                item = index.internalPointer()
-                if isinstance(item, Link):
-                    return QVariant(formatSize(item.data["size"]))
-                else:
-                    ms = 0
-                    for c in item.children:
-                        ms += c.data["size"]
-                    return QVariant(formatSize(ms))
-        elif role == Qt.EditRole:
-            if index.column() == 0:
-                return QVariant(index.internalPointer().data["name"])
-        return QVariant()
-        
-    def index(self, row, column, parent=QModelIndex()):
-        """
-            creates a cell index with pointer to the data
-        """
-        if parent == QModelIndex() and len(self._data) > row:
-            pointer = self._data[row]
-            index = self.createIndex(row, column, pointer)
-        elif parent.isValid():
-            try:
-                pointer = parent.internalPointer().children[row]
-            except:
-                return QModelIndex()
-            index = self.createIndex(row, column, pointer)
-        else:
-            index = QModelIndex()
-        return index
-    
-    def parent(self, index):
-        """
-            return index of parent element
-            only valid for links
-        """
-        if index == QModelIndex():
-            return QModelIndex()
-        if index.isValid():
-            link = index.internalPointer()
-            if isinstance(link, Link):
-                for k, pack in enumerate(self._data):
-                    if pack == link.package:
-                        return self.createIndex(k, 0, link.package)
-        return QModelIndex()
-    
-    def rowCount(self, parent=QModelIndex()):
-        """
-            returns row count for the element
-        """
-        if parent == QModelIndex():
-            #return package count
-            return len(self._data)
-        else:
-            if parent.isValid():
-                #index is valid
-                pack = parent.internalPointer()
-                if isinstance(pack, Package):
-                    #index points to a package
-                    #return len of children
-                    return len(pack.children)
-            else:
-                #index is invalid
-                return False
-        #files have no children
-        return 0
-    
-    def columnCount(self, parent=QModelIndex()):
-        return self.cols
-    
-    def hasChildren(self, parent=QModelIndex()):
-        if not parent.isValid():
-            return True
-        return self.rowCount(parent) > 0
-    
-    def canFetchMore(self, parent):
-        return False
-    
-    def headerData(self, section, orientation, role=Qt.DisplayRole):
-        """
-            returns column heading
-        """
-        if orientation == Qt.Horizontal and role == Qt.DisplayRole:
-            if section == 0:
-                return QVariant(_("Name"))
-            elif section == 1:
-                return QVariant(_("Plugin"))
-            elif section == 2:
-                return QVariant(_("Status"))
-            elif section == 3:
-                return QVariant(_("Size"))
-        return QVariant()
-    
-    def flags(self, index):
-        """
-            cell flags
-        """
-        if index.column() == 0 and self.parent(index) == QModelIndex():
-            return Qt.ItemIsSelectable | Qt.ItemIsEditable | Qt.ItemIsEnabled
-        return Qt.ItemIsSelectable | Qt.ItemIsEnabled
-   
-    def setData(self, index, value, role=Qt.EditRole):
-        """
-            called if package name editing is finished, sets new name
-        """
-        if index.column() == 0 and self.parent(index) == QModelIndex() and role == Qt.EditRole:
-            self.connector.setPackageName(index.internalPointer().id, str(value.toString()))
-        return True
-
-class Package(object):
-    """
-        package object in the model
-    """
-    
-    def __init__(self, pack):
-        self.id = pack.pid
-        self.children = []
-        for f in pack.links:
-            self.addChild(f)
-        self.data = {}
-        self.update(pack)
-    
-    def update(self, pack):
-        """
-            update data dict from thift object
-        """
-        data = {
-            "name": pack.name,
-            "folder": pack.folder,
-            "site": pack.site,
-            "password": pack.password,
-            "order": pack.order,
-        }
-        self.data.update(data)
-    
-    def addChild(self, f):
-        """
-            add child (Link) to package
-        """
-        self.children.insert(f.order, Link(f, self))
-        self.children = sorted(self.children, key=lambda l: l.data["order"])
-    
-    def getChild(self, fid):
-        """
-            get child from package
-        """
-        for child in self.children:
-            if child.id == int(fid):
-                return child
-        return None
-    
-    def getChildKey(self, fid):
-        """
-            get child index
-        """
-        for k, child in enumerate(self.children):
-            if child.id == int(fid):
-                return k
-        return None
-    
-    def removeChild(self, fid):
-        """
-            remove child
-        """
-        for k, child in enumerate(self.children):
-            if child.id == int(fid):
-                del self.children[k]
-
-class Link(object):
-    def __init__(self, f, pack):
-        self.data = {"downloading": None}
-        self.update(f)
-        self.id = f.fid
-        self.package = pack
-    
-    def update(self, f):
-        """
-            update data dict from thift object
-        """
-        data = {
-            "url": f.url,
-            "name": f.name,
-            "plugin": f.plugin,
-            "size": f.size,
-            "format_size": f.format_size,
-            "status": f.status,
-            "statusmsg": f.statusmsg,
-            "package": f.packageID,
-            "error": f.error,
-            "order": f.order,
-        }
-        self.data.update(data)
-
-class CollectorView(QTreeView):
-    """
-        view component for collector
-    """
-    
-    def __init__(self, connector):
-        QTreeView.__init__(self)
-        self.setModel(CollectorModel(self, connector))
-        self.setColumnWidth(0, 500)
-        self.setColumnWidth(1, 100)
-        self.setColumnWidth(2, 200)
-        self.setColumnWidth(3, 100)
-        
-        self.setEditTriggers(QAbstractItemView.DoubleClicked | QAbstractItemView.EditKeyPressed)
-
diff --git a/module/gui/ConnectionManager.py b/module/gui/ConnectionManager.py
deleted file mode 100644
index def575abc..000000000
--- a/module/gui/ConnectionManager.py
+++ /dev/null
@@ -1,302 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    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/>.
-    
-    @author: mkaay
-"""
-
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
-
-from os.path import join
-
-from uuid import uuid4 as uuid
-
-class ConnectionManager(QWidget):
-
-
-    warningShown = False
-
-    def __init__(self):
-        QWidget.__init__(self)
-
-        if not self.warningShown:
-            QMessageBox.warning(self, 'Warning',
-            "We are sorry but the GUI is not stable yet. Please use the webinterface for much better experience. \n", QMessageBox.Ok)
-            ConnectionManager.warningShown = True
-
-        mainLayout = QHBoxLayout()
-        buttonLayout = QVBoxLayout()
-
-        self.setWindowTitle(_("pyLoad ConnectionManager"))
-        self.setWindowIcon(QIcon(join(pypath, "icons","logo.png")))
-
-        connList = QListWidget()
-        
-        new = QPushButton(_("New"))
-        edit = QPushButton(_("Edit"))
-        remove = QPushButton(_("Remove"))
-        connect = QPushButton(_("Connect"))
-
-        #box = QFrame()
-        boxLayout = QVBoxLayout()
-        #box.setLayout(boxLayout)
-
-        boxLayout.addWidget(QLabel(_("Connect:")))
-        boxLayout.addWidget(connList)
-
-        line = QFrame()
-        #line.setFixedWidth(100)
-        line.setFrameShape(line.HLine)
-        line.setFrameShadow(line.Sunken)
-        line.setFixedHeight(10)
-
-        boxLayout.addWidget(line)
-
-        form = QFormLayout()
-        form.setMargin(5)
-        form.setSpacing(20)
-
-        form.setAlignment(Qt.AlignRight)
-        checkbox = QCheckBox()
-        form.addRow(_("Use internal Core:"), checkbox)
-
-        boxLayout.addLayout(form)
-
-        mainLayout.addLayout(boxLayout)
-        mainLayout.addLayout(buttonLayout)
-        
-        buttonLayout.addWidget(new)
-        buttonLayout.addWidget(edit)
-        buttonLayout.addWidget(remove)
-        buttonLayout.addStretch()
-        buttonLayout.addWidget(connect)
-        
-        self.setLayout(mainLayout)
-
-        self.internal = checkbox
-        self.new = new
-        self.connectb = connect
-        self.remove = remove
-        self.editb = edit
-        self.connList = connList
-        self.edit = self.EditWindow()
-        self.connectSignals()
-        
-        self.defaultStates = {}
-    
-    def connectSignals(self):
-        self.connect(self, SIGNAL("setConnections"), self.setConnections)
-        self.connect(self.new, SIGNAL("clicked()"), self.slotNew)
-        self.connect(self.editb, SIGNAL("clicked()"), self.slotEdit)
-        self.connect(self.remove, SIGNAL("clicked()"), self.slotRemove)
-        self.connect(self.connectb, SIGNAL("clicked()"), self.slotConnect)
-        self.connect(self.edit, SIGNAL("save"), self.slotSave)
-        self.connect(self.connList, SIGNAL("itemDoubleClicked(QListWidgetItem *)"), self.slotItemDoubleClicked)
-        self.connect(self.internal, SIGNAL("clicked()"), self.slotInternal)
-    
-    def setConnections(self, connections):
-        self.connList.clear()
-        for conn in connections:
-            item = QListWidgetItem()
-            item.setData(Qt.DisplayRole, QVariant(conn["name"]))
-            item.setData(Qt.UserRole, QVariant(conn))
-            self.connList.addItem(item)
-            if conn["default"]:
-                item.setData(Qt.DisplayRole, QVariant(_("%s (Default)") % conn["name"]))
-                self.connList.setCurrentItem(item)
-    
-    def slotNew(self):
-        data = {"id":uuid().hex, "type":"remote", "default":False, "name":"", "host":"", "port":"7228", "user":"admin", "password":""}
-        self.edit.setData(data)
-        self.edit.show()
-    
-    def slotEdit(self):
-        item = self.connList.currentItem()
-        data = item.data(Qt.UserRole).toPyObject()
-        data = self.cleanDict(data)
-        self.edit.setData(data)
-        self.edit.show()
-    
-    def slotRemove(self):
-        item = self.connList.currentItem()
-        data = item.data(Qt.UserRole).toPyObject()
-        data = self.cleanDict(data)
-        self.emit(SIGNAL("removeConnection"), data)
-    
-    def slotConnect(self):
-        if self.internal.checkState() == 2:
-            data = {"type": "internal"}
-            self.emit(SIGNAL("connect"), data)
-        else:
-            item = self.connList.currentItem()
-            data = item.data(Qt.UserRole).toPyObject()
-            data = self.cleanDict(data)
-            self.emit(SIGNAL("connect"), data)
-    
-    def cleanDict(self, data):
-        tmp = {}
-        for k, d in data.items():
-            tmp[str(k)] = d
-        return tmp
-    
-    def slotSave(self, data):
-        self.emit(SIGNAL("saveConnection"), data)
-        
-    def slotItemDoubleClicked(self, defaultItem):
-        data = defaultItem.data(Qt.UserRole).toPyObject()
-        self.setDefault(data, True)
-        did = self.cleanDict(data)["id"]
-        #allItems = self.connList.findItems("*", Qt.MatchWildcard)
-        count = self.connList.count()
-        for i in range(count):
-            item = self.connList.item(i)
-            data = item.data(Qt.UserRole).toPyObject()
-            if self.cleanDict(data)["id"] == did:
-                continue
-            self.setDefault(data, False)
-
-    def slotInternal(self):
-        if self.internal.checkState() == 2:
-            self.connList.clearSelection()
-    
-    def setDefault(self, data, state):
-        data = self.cleanDict(data)
-        self.edit.setData(data)
-        data = self.edit.getData()
-        data["default"] = state
-        self.edit.emit(SIGNAL("save"), data)
-    
-    class EditWindow(QWidget):
-        def __init__(self):
-            QWidget.__init__(self)
-
-            self.setWindowTitle(_("pyLoad ConnectionManager"))
-            self.setWindowIcon(QIcon(join(pypath, "icons","logo.png")))
-            
-            grid = QGridLayout()
-            
-            nameLabel = QLabel(_("Name:"))
-            hostLabel = QLabel(_("Host:"))
-            localLabel = QLabel(_("Local:"))
-            userLabel = QLabel(_("User:"))
-            pwLabel = QLabel(_("Password:"))
-            portLabel = QLabel(_("Port:"))
-            
-            name = QLineEdit()
-            host = QLineEdit()
-            local = QCheckBox()
-            user = QLineEdit()
-            password = QLineEdit()
-            password.setEchoMode(QLineEdit.Password)
-            port = QSpinBox()
-            port.setRange(1,10000)
-            
-            save = QPushButton(_("Save"))
-            cancel = QPushButton(_("Cancel"))
-            
-            grid.addWidget(nameLabel,  0, 0)
-            grid.addWidget(name,       0, 1)
-            grid.addWidget(localLabel, 1, 0)
-            grid.addWidget(local,      1, 1)
-            grid.addWidget(hostLabel,  2, 0)
-            grid.addWidget(host,       2, 1)
-            grid.addWidget(portLabel,  3, 0)
-            grid.addWidget(port,       3, 1)
-            grid.addWidget(userLabel,  4, 0)
-            grid.addWidget(user,       4, 1)
-            grid.addWidget(pwLabel,    5, 0)
-            grid.addWidget(password,   5, 1)
-            grid.addWidget(cancel,     6, 0)
-            grid.addWidget(save,       6, 1)
-            
-            self.setLayout(grid)
-            self.controls = {"name": name,
-                             "host": host,
-                             "local": local,
-                             "user": user,
-                             "password": password,
-                             "port": port,
-                             "save": save,
-                             "cancel": cancel}
-
-            self.connect(cancel, SIGNAL("clicked()"), self.hide)
-            self.connect(save, SIGNAL("clicked()"), self.slotDone)
-            self.connect(local, SIGNAL("stateChanged(int)"), self.slotLocalChanged)
-            
-            self.id = None
-            self.default = None
-        
-        def setData(self, data):
-            if not data: return
-            
-            self.id = data["id"]
-            self.default = data["default"]
-            self.controls["name"].setText(data["name"])
-            if data["type"] == "local":
-                data["local"] = True
-            else:
-                data["local"] = False
-            self.controls["local"].setChecked(data["local"])
-            if not data["local"]:
-                self.controls["user"].setText(data["user"])
-                self.controls["password"].setText(data["password"])
-                self.controls["port"].setValue(int(data["port"]))
-                self.controls["host"].setText(data["host"])
-                self.controls["user"].setDisabled(False)
-                self.controls["password"].setDisabled(False)
-                self.controls["port"].setDisabled(False)
-                self.controls["host"].setDisabled(False)
-            else:
-                self.controls["user"].setText("")
-                self.controls["port"].setValue(1)
-                self.controls["host"].setText("")
-                self.controls["user"].setDisabled(True)
-                self.controls["password"].setDisabled(True)
-                self.controls["port"].setDisabled(True)
-                self.controls["host"].setDisabled(True)
-        
-        def slotLocalChanged(self, val):
-            if val == 2:
-                self.controls["user"].setDisabled(True)
-                self.controls["password"].setDisabled(True)
-                self.controls["port"].setDisabled(True)
-                self.controls["host"].setDisabled(True)
-            elif val == 0:
-                self.controls["user"].setDisabled(False)
-                self.controls["password"].setDisabled(False)
-                self.controls["port"].setDisabled(False)
-                self.controls["host"].setDisabled(False)
-        
-        def getData(self):
-            d = {}
-            d["id"] = self.id
-            d["default"] = self.default
-            d["name"] = self.controls["name"].text()
-            d["local"] = self.controls["local"].isChecked()
-            d["user"] = self.controls["user"].text()
-            d["password"] = self.controls["password"].text()
-            d["host"] = self.controls["host"].text()
-            d["port"] = self.controls["port"].value()
-            if d["local"]:
-                d["type"] = "local"
-            else:
-                d["type"] = "remote"
-            return d
-        
-        def slotDone(self):
-            data = self.getData()
-            self.hide()
-            self.emit(SIGNAL("save"), data)
-
diff --git a/module/gui/CoreConfigParser.py b/module/gui/CoreConfigParser.py
deleted file mode 100644
index 0d1d298c6..000000000
--- a/module/gui/CoreConfigParser.py
+++ /dev/null
@@ -1,165 +0,0 @@
-# -*- coding: utf-8 -*-
-
-from __future__ import with_statement
-from os.path import exists
-from os.path import join
-
-
-CONF_VERSION = 1
-
-########################################################################
-class ConfigParser:
-
-    #----------------------------------------------------------------------
-    def __init__(self, configdir):
-        """Constructor"""
-        self.configdir = configdir
-        self.config = {}
-        
-        if self.checkVersion():
-            self.readConfig()
-    
-    #----------------------------------------------------------------------
-    def checkVersion(self):
-        
-        if not exists(join(self.configdir, "pyload.conf")):
-            return False
-        f = open(join(self.configdir, "pyload.conf"), "rb")
-        v = f.readline()
-        f.close()
-        v = v[v.find(":")+1:].strip()
-        
-        if int(v) < CONF_VERSION:
-            return False
-        
-        return True    
-        
-    #----------------------------------------------------------------------
-    def readConfig(self):
-        """reads the config file"""
-        
-        self.config = self.parseConfig(join(self.configdir, "pyload.conf"))
-        
-        
-    #----------------------------------------------------------------------
-    def parseConfig(self, config):
-        """parses a given configfile"""
-        
-        f = open(config)
-        
-        config = f.read()
-
-        config = config.split("\n")[1:]
-        
-        conf = {}
-        
-        section, option, value, typ, desc = "","","","",""
-        
-        listmode = False
-        
-        for line in config:
-            
-            line = line.rpartition("#") # removes comments
-            
-            if line[1]:
-                line = line[0]
-            else:
-                line = line[2]
-            
-            line = line.strip()            
-            
-            try:
-            
-                if line == "":
-                    continue
-                elif line.endswith(":"):
-                    section, none, desc = line[:-1].partition('-')
-                    section = section.strip()
-                    desc = desc.replace('"', "").strip()
-                    conf[section] = { "desc" : desc }
-                else:
-                    if listmode:
-                        
-                        if line.endswith("]"):
-                            listmode = False
-                            line = line.replace("]","")
-                            
-                        value += [self.cast(typ, x.strip()) for x in line.split(",") if x]
-                        
-                        if not listmode:
-                            conf[section][option] = { "desc" : desc,
-                                                      "type" : typ,
-                                                      "value" : value} 
-                        
-                        
-                    else:
-                        content, none, value = line.partition("=")
-                        
-                        content, none, desc = content.partition(":")
-                        
-                        desc = desc.replace('"', "").strip()
-    
-                        typ, option = content.split()
-                                                
-                        value = value.strip()
-                        
-                        if value.startswith("["):
-                            if value.endswith("]"):                            
-                                listmode = False
-                                value = value[:-1]
-                            else:
-                                listmode = True
-                          
-                            value = [self.cast(typ, x.strip()) for x in value[1:].split(",") if x]
-                        else:
-                            value = self.cast(typ, value)
-                        
-                        if not listmode:
-                            conf[section][option] = { "desc" : desc,
-                                                      "type" : typ,
-                                                      "value" : value}
-                
-            except:
-                pass
-                    
-                        
-        f.close()
-        return conf
-        
-    #----------------------------------------------------------------------
-    def cast(self, typ, value):
-        """cast value to given format"""
-        if type(value) not in (str, unicode):
-            return value
-        
-        if typ == "int":
-            return int(value)
-        elif typ == "bool":
-            return True if value.lower() in ("1","true", "on", "an","yes") else False
-        else:
-            return value
-        
-    #----------------------------------------------------------------------
-    def get(self, section, option):
-        """get value"""
-        return self.config[section][option]["value"]
-    
-    #----------------------------------------------------------------------
-    def __getitem__(self, section):
-        """provides dictonary like access: c['section']['option']"""
-        return Section(self, section)
-
-########################################################################
-class Section:
-    """provides dictionary like access for configparser"""
-
-    #----------------------------------------------------------------------
-    def __init__(self, parser, section):
-        """Constructor"""
-        self.parser = parser
-        self.section = section
-        
-    #----------------------------------------------------------------------
-    def __getitem__(self, item):
-        """getitem"""
-        return self.parser.get(self.section, item)
diff --git a/module/gui/LinkDock.py b/module/gui/LinkDock.py
deleted file mode 100644
index ac2d4aae5..000000000
--- a/module/gui/LinkDock.py
+++ /dev/null
@@ -1,56 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    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/>.
-    
-    @author: mkaay
-"""
-
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
-
-class NewLinkDock(QDockWidget):
-    def __init__(self):
-        QDockWidget.__init__(self, "New Links")
-        self.setObjectName("New Links Dock")
-        self.widget = NewLinkWindow(self)
-        self.setWidget(self.widget)
-        self.setAllowedAreas(Qt.RightDockWidgetArea|Qt.LeftDockWidgetArea)
-        self.hide()
-    
-    def slotDone(self):
-        text = str(self.widget.box.toPlainText())
-        lines = text.splitlines()
-        self.emit(SIGNAL("done"), lines)
-        self.widget.box.clear()
-        self.hide()
-
-class NewLinkWindow(QWidget):
-    def __init__(self, dock):
-        QWidget.__init__(self)
-        self.dock = dock
-        self.setLayout(QVBoxLayout())
-        layout = self.layout()
-        
-        explanationLabel = QLabel("Select a package and then click Add button.")
-        boxLabel = QLabel("Paste URLs here:")
-        self.box = QTextEdit()
-        
-        save = QPushButton("Add")
-        
-        layout.addWidget(explanationLabel)
-        layout.addWidget(boxLabel)
-        layout.addWidget(self.box)
-        layout.addWidget(save)
-        
-        self.connect(save, SIGNAL("clicked()"), self.dock.slotDone)
diff --git a/module/gui/MainWindow.py b/module/gui/MainWindow.py
deleted file mode 100644
index c71112e9b..000000000
--- a/module/gui/MainWindow.py
+++ /dev/null
@@ -1,697 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    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/>.
-    
-    @author: mkaay
-"""
-
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
-
-from os.path import join
-
-from module.gui.PackageDock import *
-from module.gui.LinkDock import *
-from module.gui.CaptchaDock import CaptchaDock
-from module.gui.SettingsWidget import SettingsWidget
-
-from module.gui.Collector import CollectorView, Package, Link
-from module.gui.Queue import QueueView
-from module.gui.Overview import OverviewView
-from module.gui.Accounts import AccountView
-from module.gui.AccountEdit import AccountEdit
-
-from module.remote.thriftbackend.ThriftClient import AccountInfo
-
-class MainWindow(QMainWindow):
-    def __init__(self, connector):
-        """
-            set up main window
-        """
-        QMainWindow.__init__(self)
-        #window stuff
-        self.setWindowTitle(_("pyLoad Client"))
-        self.setWindowIcon(QIcon(join(pypath, "icons","logo.png")))
-        self.resize(1000,600)
-        
-        #layout version
-        self.version = 3
-        
-        #init docks
-        self.newPackDock = NewPackageDock()
-        self.addDockWidget(Qt.RightDockWidgetArea, self.newPackDock)
-        self.connect(self.newPackDock, SIGNAL("done"), self.slotAddPackage)
-        self.captchaDock = CaptchaDock()
-        self.addDockWidget(Qt.BottomDockWidgetArea, self.captchaDock)
-        self.newLinkDock = NewLinkDock()
-        self.addDockWidget(Qt.RightDockWidgetArea, self.newLinkDock)
-        self.connect(self.newLinkDock, SIGNAL("done"), self.slotAddLinksToPackage)
-        
-        #central widget, layout
-        self.masterlayout = QVBoxLayout()
-        lw = QWidget()
-        lw.setLayout(self.masterlayout)
-        self.setCentralWidget(lw)
-        
-        #status
-        self.statusw = QFrame()
-        self.statusw.setFrameStyle(QFrame.StyledPanel | QFrame.Raised)
-        self.statusw.setLineWidth(2)
-        self.statusw.setLayout(QGridLayout())
-        #palette = self.statusw.palette()
-        #palette.setColor(QPalette.Window, QColor(255, 255, 255))
-        #self.statusw.setPalette(palette)
-        #self.statusw.setAutoFillBackground(True)
-        l = self.statusw.layout()
-        
-        class BoldLabel(QLabel):
-            def __init__(self, text):
-                QLabel.__init__(self, text)
-                f = self.font()
-                f.setBold(True)
-                self.setFont(f)
-                self.setAlignment(Qt.AlignRight)
-        
-        class Seperator(QFrame):
-            def __init__(self):
-                QFrame.__init__(self)
-                self.setFrameShape(QFrame.VLine)
-                self.setFrameShadow(QFrame.Sunken)
-        
-        l.addWidget(BoldLabel(_("Packages:")), 0, 0)
-        self.packageCount = QLabel("0")
-        l.addWidget(self.packageCount, 0, 1)
-        
-        l.addWidget(BoldLabel(_("Files:")), 0, 2)
-        self.fileCount = QLabel("0")
-        l.addWidget(self.fileCount, 0, 3)
-        
-        l.addWidget(BoldLabel(_("Status:")), 0, 4)
-        self.status = QLabel("running")
-        l.addWidget(self.status, 0, 5)
-        
-        l.addWidget(BoldLabel(_("Space:")), 0, 6)
-        self.space = QLabel("")
-        l.addWidget(self.space, 0, 7)
-        
-        l.addWidget(BoldLabel(_("Speed:")), 0, 8)
-        self.speed = QLabel("")
-        l.addWidget(self.speed, 0, 9)
-        
-        #l.addWidget(BoldLabel(_("Max. downloads:")), 0, 9)
-        #l.addWidget(BoldLabel(_("Max. chunks:")), 1, 9)
-        #self.maxDownloads = QSpinBox()
-        #self.maxDownloads.setEnabled(False)
-        #self.maxChunks = QSpinBox()
-        #self.maxChunks.setEnabled(False)
-        #l.addWidget(self.maxDownloads, 0, 10)
-        #l.addWidget(self.maxChunks, 1, 10)
-
-        #set menubar and statusbar
-        self.menubar = self.menuBar()
-        #self.statusbar = self.statusBar()
-        #self.connect(self.statusbar, SIGNAL("showMsg"), self.statusbar.showMessage)
-        #self.serverStatus = QLabel(_("Status: Not Connected"))
-        #self.statusbar.addPermanentWidget(self.serverStatus)
-        
-        #menu
-        self.menus = {"file": self.menubar.addMenu(_("File")),
-                      "connections": self.menubar.addMenu(_("Connections"))}
-
-        #menu actions
-        self.mactions = {"exit": QAction(_("Exit"), self.menus["file"]),
-                         "manager": QAction(_("Connection manager"), self.menus["connections"])}
-
-        #add menu actions
-        self.menus["file"].addAction(self.mactions["exit"])
-        self.menus["connections"].addAction(self.mactions["manager"])
-        
-        #toolbar
-        self.actions = {}
-        self.init_toolbar()
-        
-        #tabs
-        self.tabw = QTabWidget()
-        self.tabs = {"overview": {"w": QWidget()},
-                     "queue": {"w": QWidget()},
-                     "collector": {"w": QWidget()},
-                     "accounts": {"w": QWidget()},
-                     "settings": {}}
-        #self.tabs["settings"]["s"] = QScrollArea()
-        self.tabs["settings"]["w"] = SettingsWidget()
-        #self.tabs["settings"]["s"].setWidgetResizable(True)
-        #self.tabs["settings"]["s"].setWidget(self.tabs["settings"]["w"])
-        self.tabs["log"] = {"w":QWidget()}
-        self.tabw.addTab(self.tabs["overview"]["w"], _("Overview"))
-        self.tabw.addTab(self.tabs["queue"]["w"], _("Queue"))
-        self.tabw.addTab(self.tabs["collector"]["w"], _("Collector"))
-        self.tabw.addTab(self.tabs["accounts"]["w"], _("Accounts"))
-        self.tabw.addTab(self.tabs["settings"]["w"], _("Settings"))
-        self.tabw.addTab(self.tabs["log"]["w"], _("Log"))
-        
-        #init tabs
-        self.init_tabs(connector)
-        
-        #context menus
-        self.init_context()
-        
-        #layout
-        self.masterlayout.addWidget(self.tabw)
-        self.masterlayout.addWidget(self.statusw)
-        
-        #signals..
-        self.connect(self.mactions["manager"], SIGNAL("triggered()"), self.slotShowConnector)
-        
-        self.connect(self.tabs["queue"]["view"], SIGNAL('customContextMenuRequested(const QPoint &)'), self.slotQueueContextMenu)
-        self.connect(self.tabs["collector"]["package_view"], SIGNAL('customContextMenuRequested(const QPoint &)'), self.slotCollectorContextMenu)
-        self.connect(self.tabs["accounts"]["view"], SIGNAL('customContextMenuRequested(const QPoint &)'), self.slotAccountContextMenu)
-        
-        self.connect(self.tabw, SIGNAL("currentChanged(int)"), self.slotTabChanged)
-        
-        self.lastAddedID = None
-        
-        self.connector = connector
-    
-    def init_toolbar(self):
-        """
-            create toolbar
-        """
-        self.toolbar = self.addToolBar(_("Hide Toolbar"))
-        self.toolbar.setObjectName("Main Toolbar")
-        self.toolbar.setIconSize(QSize(30,30))
-        self.toolbar.setMovable(False)
-        self.actions["toggle_status"] = self.toolbar.addAction(_("Toggle Pause/Resume"))
-        pricon = QIcon()
-        pricon.addFile(join(pypath, "icons","toolbar_start.png"), QSize(), QIcon.Normal, QIcon.Off)
-        pricon.addFile(join(pypath, "icons","toolbar_pause.png"), QSize(), QIcon.Normal, QIcon.On)
-        self.actions["toggle_status"].setIcon(pricon)
-        self.actions["toggle_status"].setCheckable(True)
-        self.actions["status_stop"] = self.toolbar.addAction(QIcon(join(pypath, "icons","toolbar_stop.png")), _("Stop"))
-        self.toolbar.addSeparator()
-        self.actions["add"] = self.toolbar.addAction(QIcon(join(pypath, "icons","toolbar_add.png")), _("Add"))
-        self.toolbar.addSeparator()
-        self.actions["clipboard"] = self.toolbar.addAction(QIcon(join(pypath, "icons","clipboard.png")), _("Check Clipboard"))
-        self.actions["clipboard"].setCheckable(True)
-        
-        self.connect(self.actions["toggle_status"], SIGNAL("toggled(bool)"), self.slotToggleStatus)
-        self.connect(self.actions["clipboard"], SIGNAL("toggled(bool)"), self.slotToggleClipboard)
-        self.connect(self.actions["status_stop"], SIGNAL("triggered()"), self.slotStatusStop)
-        self.addMenu = QMenu()
-        packageAction = self.addMenu.addAction(_("Package"))
-        containerAction = self.addMenu.addAction(_("Container"))
-        accountAction = self.addMenu.addAction(_("Account"))
-        linksAction = self.addMenu.addAction(_("Links"))
-        self.connect(self.actions["add"], SIGNAL("triggered()"), self.slotAdd)
-        self.connect(packageAction, SIGNAL("triggered()"), self.slotShowAddPackage)
-        self.connect(containerAction, SIGNAL("triggered()"), self.slotShowAddContainer)
-        self.connect(accountAction, SIGNAL("triggered()"), self.slotNewAccount)
-        self.connect(linksAction, SIGNAL("triggered()"), self.slotShowAddLinks)
-    
-    def init_tabs(self, connector):
-        """
-            create tabs
-        """
-        #overview
-        self.tabs["overview"]["l"] = QGridLayout()
-        self.tabs["overview"]["w"].setLayout(self.tabs["overview"]["l"])
-        self.tabs["overview"]["view"] = OverviewView(connector)
-        self.tabs["overview"]["l"].addWidget(self.tabs["overview"]["view"])
-        
-        #queue
-        self.tabs["queue"]["l"] = QGridLayout()
-        self.tabs["queue"]["w"].setLayout(self.tabs["queue"]["l"])
-        self.tabs["queue"]["view"] = QueueView(connector)
-        self.tabs["queue"]["l"].addWidget(self.tabs["queue"]["view"])
-        
-        #collector
-        toQueue = QPushButton(_("Push selected packages to queue"))
-        self.tabs["collector"]["l"] = QGridLayout()
-        self.tabs["collector"]["w"].setLayout(self.tabs["collector"]["l"])
-        self.tabs["collector"]["package_view"] = CollectorView(connector)
-        self.tabs["collector"]["l"].addWidget(self.tabs["collector"]["package_view"], 0, 0)
-        self.tabs["collector"]["l"].addWidget(toQueue, 1, 0)
-        self.connect(toQueue, SIGNAL("clicked()"), self.slotPushPackageToQueue)
-        self.tabs["collector"]["package_view"].setContextMenuPolicy(Qt.CustomContextMenu)
-        self.tabs["queue"]["view"].setContextMenuPolicy(Qt.CustomContextMenu)
-        
-        #log
-        self.tabs["log"]["l"] = QGridLayout()
-        self.tabs["log"]["w"].setLayout(self.tabs["log"]["l"])
-        self.tabs["log"]["text"] = QTextEdit()
-        self.tabs["log"]["text"].logOffset = 0
-        self.tabs["log"]["text"].setReadOnly(True)
-        self.connect(self.tabs["log"]["text"], SIGNAL("append(QString)"), self.tabs["log"]["text"].append)
-        self.tabs["log"]["l"].addWidget(self.tabs["log"]["text"])
-        
-        #accounts
-        self.tabs["accounts"]["view"] = AccountView(connector)
-        self.tabs["accounts"]["w"].setLayout(QVBoxLayout())
-        self.tabs["accounts"]["w"].layout().addWidget(self.tabs["accounts"]["view"])
-        newbutton = QPushButton(_("New Account"))
-        self.tabs["accounts"]["w"].layout().addWidget(newbutton)
-        self.connect(newbutton, SIGNAL("clicked()"), self.slotNewAccount)
-        self.tabs["accounts"]["view"].setContextMenuPolicy(Qt.CustomContextMenu)
-    
-    def init_context(self):
-        """
-            create context menus
-        """
-        self.activeMenu = None
-        #queue
-        self.queueContext = QMenu()
-        self.queueContext.buttons = {}
-        self.queueContext.item = (None, None)
-        self.queueContext.buttons["remove"] = QAction(QIcon(join(pypath, "icons","remove_small.png")), _("Remove"), self.queueContext)
-        self.queueContext.buttons["restart"] = QAction(QIcon(join(pypath, "icons","refresh_small.png")), _("Restart"), self.queueContext)
-        self.queueContext.buttons["pull"] = QAction(QIcon(join(pypath, "icons","pull_small.png")), _("Pull out"), self.queueContext)
-        self.queueContext.buttons["abort"] = QAction(QIcon(join(pypath, "icons","abort.png")), _("Abort"), self.queueContext)
-        self.queueContext.buttons["edit"] = QAction(QIcon(join(pypath, "icons","edit_small.png")), _("Edit Name"), self.queueContext)
-        self.queueContext.addAction(self.queueContext.buttons["pull"])
-        self.queueContext.addAction(self.queueContext.buttons["edit"])
-        self.queueContext.addAction(self.queueContext.buttons["remove"])
-        self.queueContext.addAction(self.queueContext.buttons["restart"])
-        self.queueContext.addAction(self.queueContext.buttons["abort"])
-        self.connect(self.queueContext.buttons["remove"], SIGNAL("triggered()"), self.slotRemoveDownload)
-        self.connect(self.queueContext.buttons["restart"], SIGNAL("triggered()"), self.slotRestartDownload)
-        self.connect(self.queueContext.buttons["pull"], SIGNAL("triggered()"), self.slotPullOutPackage)
-        self.connect(self.queueContext.buttons["abort"], SIGNAL("triggered()"), self.slotAbortDownload)
-        self.connect(self.queueContext.buttons["edit"], SIGNAL("triggered()"), self.slotEditPackage)
-        
-        #collector
-        self.collectorContext = QMenu()
-        self.collectorContext.buttons = {}
-        self.collectorContext.item = (None, None)
-        self.collectorContext.buttons["remove"] = QAction(QIcon(join(pypath, "icons","remove_small.png")), _("Remove"), self.collectorContext)
-        self.collectorContext.buttons["push"] = QAction(QIcon(join(pypath, "icons","push_small.png")), _("Push to queue"), self.collectorContext)
-        self.collectorContext.buttons["edit"] = QAction(QIcon(join(pypath, "icons","edit_small.png")), _("Edit Name"), self.collectorContext)
-        self.collectorContext.buttons["restart"] = QAction(QIcon(join(pypath, "icons","refresh_small.png")), _("Restart"), self.collectorContext)
-        self.collectorContext.buttons["refresh"] = QAction(QIcon(join(pypath, "icons","refresh1_small.png")),_("Refresh Status"), self.collectorContext)
-        self.collectorContext.addAction(self.collectorContext.buttons["push"])
-        self.collectorContext.addSeparator()
-        self.collectorContext.buttons["add"] = self.collectorContext.addMenu(QIcon(join(pypath, "icons","add_small.png")), _("Add"))
-        self.collectorContext.addAction(self.collectorContext.buttons["edit"])
-        self.collectorContext.addAction(self.collectorContext.buttons["remove"])
-        self.collectorContext.addAction(self.collectorContext.buttons["restart"])
-        self.collectorContext.addSeparator()
-        self.collectorContext.addAction(self.collectorContext.buttons["refresh"])
-        packageAction = self.collectorContext.buttons["add"].addAction(_("Package"))
-        containerAction = self.collectorContext.buttons["add"].addAction(_("Container"))
-        linkAction = self.collectorContext.buttons["add"].addAction(_("Links"))
-        self.connect(self.collectorContext.buttons["remove"], SIGNAL("triggered()"), self.slotRemoveDownload)
-        self.connect(self.collectorContext.buttons["push"], SIGNAL("triggered()"), self.slotPushPackageToQueue)
-        self.connect(self.collectorContext.buttons["edit"], SIGNAL("triggered()"), self.slotEditPackage)
-        self.connect(self.collectorContext.buttons["restart"], SIGNAL("triggered()"), self.slotRestartDownload)
-        self.connect(self.collectorContext.buttons["refresh"], SIGNAL("triggered()"), self.slotRefreshPackage)
-        self.connect(packageAction, SIGNAL("triggered()"), self.slotShowAddPackage)
-        self.connect(containerAction, SIGNAL("triggered()"), self.slotShowAddContainer)
-        self.connect(linkAction, SIGNAL("triggered()"), self.slotShowAddLinks)
-        
-        self.accountContext = QMenu()
-        self.accountContext.buttons = {}
-        self.accountContext.buttons["add"] = QAction(QIcon(join(pypath, "icons","add_small.png")), _("Add"), self.accountContext)
-        self.accountContext.buttons["remove"] = QAction(QIcon(join(pypath, "icons","remove_small.png")), _("Remove"), self.accountContext)
-        self.accountContext.buttons["edit"] = QAction(QIcon(join(pypath, "icons","edit_small.png")), _("Edit"), self.accountContext)
-        self.accountContext.addAction(self.accountContext.buttons["add"])
-        self.accountContext.addAction(self.accountContext.buttons["edit"])
-        self.accountContext.addAction(self.accountContext.buttons["remove"])
-        self.connect(self.accountContext.buttons["add"], SIGNAL("triggered()"), self.slotNewAccount)
-        self.connect(self.accountContext.buttons["edit"], SIGNAL("triggered()"), self.slotEditAccount)
-        self.connect(self.accountContext.buttons["remove"], SIGNAL("triggered()"), self.slotRemoveAccount)
-    
-    def slotToggleStatus(self, status):
-        """
-            pause/start toggle (toolbar)
-        """
-        self.emit(SIGNAL("setDownloadStatus"), status)
-    
-    def slotStatusStop(self):
-        """
-            stop button (toolbar)
-        """
-        self.emit(SIGNAL("stopAllDownloads"))
-    
-    def slotAdd(self):
-        """
-            add button (toolbar)
-            show context menu (choice: links/package)
-        """
-        self.addMenu.exec_(QCursor.pos())
-    
-    def slotShowAddPackage(self):
-        """
-            action from add-menu
-            show new-package dock
-        """
-        self.tabw.setCurrentIndex(1)
-        self.newPackDock.show()
-    
-    def slotShowAddLinks(self):
-        """
-            action from add-menu
-            show new-links dock
-        """
-        self.tabw.setCurrentIndex(1)
-        self.newLinkDock.show()
-    
-    def slotShowConnector(self):
-        """
-            connectionmanager action triggered
-            let main to the stuff
-        """
-        self.emit(SIGNAL("connector"))
-    
-    def slotAddPackage(self, name, links, password=None):
-        """
-            new package
-            let main to the stuff
-        """
-        self.emit(SIGNAL("addPackage"), name, links, password)
-        
-    def slotAddLinksToPackage(self, links):
-        """
-            adds links to currently selected package
-            only in collector
-        """
-        if self.tabw.currentIndex() != 1:
-            return
-        
-        smodel = self.tabs["collector"]["package_view"].selectionModel()
-        for index in smodel.selectedRows(0):
-            item = index.internalPointer()
-            if isinstance(item, Package):
-                self.connector.proxy.addFiles(item.id, links)
-                break
-    
-    def slotShowAddContainer(self):
-        """
-            action from add-menu
-            show file selector, emit upload
-        """
-        typeStr = ";;".join([
-            _("All Container Types (%s)") % "*.dlc *.ccf *.rsdf *.txt",
-            _("DLC (%s)") % "*.dlc",
-            _("CCF (%s)") % "*.ccf",
-            _("RSDF (%s)") % "*.rsdf",
-            _("Text Files (%s)") % "*.txt"
-        ])
-        fileNames = QFileDialog.getOpenFileNames(self, _("Open container"), "", typeStr)
-        for name in fileNames:
-            self.emit(SIGNAL("addContainer"), str(name))
-    
-    def slotPushPackageToQueue(self):
-        """
-            push collector pack to queue
-            get child ids
-            let main to the rest
-        """
-        smodel = self.tabs["collector"]["package_view"].selectionModel()
-        for index in smodel.selectedRows(0):
-            item = index.internalPointer()
-            if isinstance(item, Package):
-                self.emit(SIGNAL("pushPackageToQueue"), item.id)
-            else:
-                self.emit(SIGNAL("pushPackageToQueue"), item.package.id)
-    
-    def saveWindow(self):
-        """
-            get window state/geometry
-            pass data to main
-        """
-        state_raw = self.saveState(self.version)
-        geo_raw = self.saveGeometry()
-        
-        state = str(state_raw.toBase64())
-        geo = str(geo_raw.toBase64())
-        
-        self.emit(SIGNAL("saveMainWindow"), state, geo)
-    
-    def closeEvent(self, event):
-        """
-            somebody wants to close me!
-            let me first save my state
-        """
-        self.saveWindow()
-        event.ignore()
-        self.hide()
-        self.emit(SIGNAL("hidden"))
-        
-        # quit when no tray is available
-        if not QSystemTrayIcon.isSystemTrayAvailable():
-            self.emit(SIGNAL("Quit"))
-    
-    def restoreWindow(self, state, geo):
-        """
-            restore window state/geometry
-        """
-        state = QByteArray(state)
-        geo = QByteArray(geo)
-        
-        state_raw = QByteArray.fromBase64(state)
-        geo_raw = QByteArray.fromBase64(geo)
-        
-        self.restoreState(state_raw, self.version)
-        self.restoreGeometry(geo_raw)
-    
-    def slotQueueContextMenu(self, pos):
-        """
-            custom context menu in queue view requested
-        """
-        globalPos = self.tabs["queue"]["view"].mapToGlobal(pos)
-        i = self.tabs["queue"]["view"].indexAt(pos)
-        if not i:
-            return
-        item = i.internalPointer()
-        menuPos = QCursor.pos()
-        menuPos.setX(menuPos.x()+2)
-        self.activeMenu = self.queueContext
-        showAbort = False
-        if isinstance(item, Link) and item.data["downloading"]:
-            showAbort = True
-        elif isinstance(item, Package):
-            for child in item.children:
-                if child.data["downloading"]:
-                    showAbort = True
-                    break
-        if showAbort:
-            self.queueContext.buttons["abort"].setEnabled(True)
-        else:
-            self.queueContext.buttons["abort"].setEnabled(False)
-        if isinstance(item, Package):
-            self.queueContext.index = i
-            #self.queueContext.buttons["remove"].setEnabled(True)
-            #self.queueContext.buttons["restart"].setEnabled(True)
-            self.queueContext.buttons["pull"].setEnabled(True)
-            self.queueContext.buttons["edit"].setEnabled(True)
-        elif isinstance(item, Link):
-            self.collectorContext.index = i
-            self.collectorContext.buttons["edit"].setEnabled(False)
-            self.collectorContext.buttons["remove"].setEnabled(True)
-            self.collectorContext.buttons["push"].setEnabled(False)
-            self.collectorContext.buttons["restart"].setEnabled(True)
-        else:
-            self.queueContext.index = None
-            #self.queueContext.buttons["remove"].setEnabled(False)
-            #self.queueContext.buttons["restart"].setEnabled(False)
-            self.queueContext.buttons["pull"].setEnabled(False)
-            self.queueContext.buttons["edit"].setEnabled(False)
-        self.queueContext.exec_(menuPos)
-    
-    def slotCollectorContextMenu(self, pos):
-        """
-            custom context menu in package collector view requested
-        """
-        globalPos = self.tabs["collector"]["package_view"].mapToGlobal(pos)
-        i = self.tabs["collector"]["package_view"].indexAt(pos)
-        if not i:
-            return
-        item = i.internalPointer()
-        menuPos = QCursor.pos()
-        menuPos.setX(menuPos.x()+2)
-        self.activeMenu = self.collectorContext
-        if isinstance(item, Package):
-            self.collectorContext.index = i
-            self.collectorContext.buttons["edit"].setEnabled(True)
-            self.collectorContext.buttons["remove"].setEnabled(True)
-            self.collectorContext.buttons["push"].setEnabled(True)
-            self.collectorContext.buttons["restart"].setEnabled(True)
-        elif isinstance(item, Link):
-            self.collectorContext.index = i
-            self.collectorContext.buttons["edit"].setEnabled(False)
-            self.collectorContext.buttons["remove"].setEnabled(True)
-            self.collectorContext.buttons["push"].setEnabled(False)
-            self.collectorContext.buttons["restart"].setEnabled(True)
-        else:
-            self.collectorContext.index = None
-            self.collectorContext.buttons["edit"].setEnabled(False)
-            self.collectorContext.buttons["remove"].setEnabled(False)
-            self.collectorContext.buttons["push"].setEnabled(False)
-            self.collectorContext.buttons["restart"].setEnabled(False)
-        self.collectorContext.exec_(menuPos)
-    
-    def slotLinkCollectorContextMenu(self, pos):
-        """
-            custom context menu in link collector view requested
-        """
-        pass
-    
-    def slotRestartDownload(self):
-        """
-            restart download action is triggered
-        """
-        smodel = self.tabs["queue"]["view"].selectionModel()
-        for index in smodel.selectedRows(0):
-            item = index.internalPointer()
-            self.emit(SIGNAL("restartDownload"), item.id, isinstance(item, Package))
-    
-    def slotRemoveDownload(self):
-        """
-            remove download action is triggered
-        """
-        if self.activeMenu == self.queueContext:
-            view = self.tabs["queue"]["view"]
-        else:
-            view = self.tabs["collector"]["package_view"]
-        smodel = view.selectionModel()
-        for index in smodel.selectedRows(0):
-            item = index.internalPointer()
-            self.emit(SIGNAL("removeDownload"), item.id, isinstance(item, Package))
-    
-    def slotToggleClipboard(self, status):
-        """
-            check clipboard (toolbar)
-        """
-        self.emit(SIGNAL("setClipboardStatus"), status)
-    
-    def slotEditPackage(self):
-        # in Queue, only edit name
-        if self.activeMenu == self.queueContext:
-            view = self.tabs["queue"]["view"]
-        else:
-            view = self.tabs["collector"]["package_view"]
-        view.edit(self.activeMenu.index)
-
-    def slotEditCommit(self, editor):
-        self.emit(SIGNAL("changePackageName"), self.activeMenu.index.internalPointer().id, editor.text())
-    
-    def slotPullOutPackage(self):
-        """
-            pull package out of the queue
-        """
-        smodel = self.tabs["queue"]["view"].selectionModel()
-        for index in smodel.selectedRows(0):
-            item = index.internalPointer()
-            if isinstance(item, Package):
-                self.emit(SIGNAL("pullOutPackage"), item.id)
-            else:
-                self.emit(SIGNAL("pullOutPackage"), item.package.id)
-    
-    def slotAbortDownload(self):
-        view = self.tabs["queue"]["view"]
-        smodel = view.selectionModel()
-        for index in smodel.selectedRows(0):
-            item = index.internalPointer()
-            self.emit(SIGNAL("abortDownload"), item.id, isinstance(item, Package))
-    
-    # TODO disabled because changing desktop on linux, main window disappears
-    #def changeEvent(self, e):
-    #    if e.type() == QEvent.WindowStateChange and self.isMinimized():
-    #        e.ignore()
-    #        self.hide()
-    #        self.emit(SIGNAL("hidden"))
-    #    else:
-    #        super(MainWindow, self).changeEvent(e)
-    
-    def slotTabChanged(self, index):
-        if index == 2:
-            self.emit(SIGNAL("reloadAccounts"))
-        elif index == 3:
-            self.tabs["settings"]["w"].loadConfig()
-    
-    def slotRefreshPackage(self):
-        smodel = self.tabs["collector"]["package_view"].selectionModel()
-        for index in smodel.selectedRows(0):
-            item = index.internalPointer()
-            pid = item.id
-            if isinstance(item, Link):
-                pid = item.package.id
-            self.emit(SIGNAL("refreshStatus"), pid)
-    
-    def slotNewAccount(self):
-        types = self.connector.proxy.getAccountTypes()
-        self.accountEdit = AccountEdit.newAccount(types)
-        
-        #TODO make more easy n1, n2, n3 
-        def save(data):
-            if data["password"]:
-                self.accountEdit.close()
-                n1 = data["acctype"]
-                n2 = data["login"]
-                n3 = data["password"]
-                self.connector.updateAccount(n1, n2, n3, None)
-            
-        self.accountEdit.connect(self.accountEdit, SIGNAL("done"), save)
-        self.accountEdit.show()
-
-    def slotEditAccount(self):
-        types = self.connector.getAccountTypes()
-        
-        data = self.tabs["accounts"]["view"].selectedIndexes()
-        if len(data) < 1:
-            return
-            
-        data = data[0].internalPointer()
-        
-        self.accountEdit = AccountEdit.editAccount(types, data)
-
-        #TODO make more easy n1, n2, n3
-        #TODO reload accounts tab after insert of edit account
-        #TODO if account does not exist give error
-        def save(data):
-            self.accountEdit.close()
-            n1 = data["acctype"]
-            n2 = data["login"]
-            if data["password"]:
-                n3 = data["password"]
-            self.connector.updateAccount(n1, n2, n3, None)
-            
-        self.accountEdit.connect(self.accountEdit, SIGNAL("done"), save)
-        self.accountEdit.show()
-    
-    def slotRemoveAccount(self):
-        data = self.tabs["accounts"]["view"].selectedIndexes()
-        if len(data) < 1:
-            return
-            
-        data = data[0].internalPointer()
-        
-        self.connector.removeAccount(data.type, data.login)
-    
-    def slotAccountContextMenu(self, pos):
-        globalPos = self.tabs["accounts"]["view"].mapToGlobal(pos)
-        i = self.tabs["accounts"]["view"].indexAt(pos)
-        if not i:
-            return
-            
-        data = i.internalPointer()
-        
-        if data is None:
-            self.accountContext.buttons["edit"].setEnabled(False)
-            self.accountContext.buttons["remove"].setEnabled(False)
-        else:
-            self.accountContext.buttons["edit"].setEnabled(True)
-            self.accountContext.buttons["remove"].setEnabled(True)
-        
-        menuPos = QCursor.pos()
-        menuPos.setX(menuPos.x()+2)
-        self.accountContext.exec_(menuPos)
diff --git a/module/gui/Overview.py b/module/gui/Overview.py
deleted file mode 100644
index 183383b5e..000000000
--- a/module/gui/Overview.py
+++ /dev/null
@@ -1,197 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    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/>.
-    
-    @author: mkaay
-"""
-
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
-
-from module.utils import formatSpeed, formatSize
-
-class OverviewModel(QAbstractListModel):
-    PackageName = 10
-    Progress = 11
-    PartsFinished = 12
-    Parts = 13
-    ETA = 14
-    Speed = 15
-    CurrentSize = 16
-    MaxSize = 17
-    Status = 18
-    
-    def __init__(self, view, connector):
-        QAbstractListModel.__init__(self)
-        
-        self.packages = []
-    
-    def queueChanged(self): #dirty..
-        self.beginResetModel()
-        
-        self.packages = []
-        
-        def partsFinished(p):
-            f = 0
-            for c in p.children:
-                if c.data["status"] == 0:
-                    f += 1
-            return f
-        
-        def maxSize(p):
-            ms = 0
-            cs = 0
-            for c in p.children:
-                try:
-                    s = c.data["downloading"]["size"]
-                except:
-                    s = c.data["size"]
-                if c.data["downloading"]:
-                    cs += s - c.data["downloading"]["bleft"]
-                elif self.queue.getProgress(c, False) == 100:
-                    cs += s
-                ms += s
-            return ms, cs
-        
-        def getProgress(p):
-            for c in p.children:
-                if c.data["status"] == 13:
-                    pass # TODO return _("Unpacking"), int(c.data["progress"])
-            return _("Downloading"), self.queue.getProgress(p)
-        
-        d = self.queue._data
-        for p in d:
-            status, progress = getProgress(p)
-            maxsize, currentsize = maxSize(p)
-            speed = self.queue.getSpeed(p)
-            if speed:
-                eta = (maxsize - (maxsize * (progress/100.0)))/speed
-            else:
-                eta = 0
-            if not speed and not progress:
-                status = _("Queued")
-            info = {
-                OverviewModel.PackageName: p.data["name"],
-                OverviewModel.Progress: progress,
-                OverviewModel.PartsFinished: partsFinished(p),
-                OverviewModel.Parts: len(p.children),
-                OverviewModel.ETA: int(eta),
-                OverviewModel.Speed: speed,
-                OverviewModel.CurrentSize: currentsize,
-                OverviewModel.MaxSize: maxsize,
-                OverviewModel.Status: status,
-            }
-            
-            self.packages.append(info)
-        
-        self.endResetModel()
-        
-    def headerData(self, section, orientation, role=Qt.DisplayRole):
-        return QVariant(_("Package"))
-    
-    def rowCount(self, parent=QModelIndex()):
-        return len(self.packages)
-    
-    def data(self, index, role=Qt.DisplayRole):
-        if role in [OverviewModel.PackageName, OverviewModel.Progress, OverviewModel.PartsFinished, OverviewModel.Parts, OverviewModel.ETA, OverviewModel.Speed, OverviewModel.CurrentSize, OverviewModel.MaxSize, OverviewModel.Status]:
-            return QVariant(self.packages[index.row()][role])
-        return QVariant()
-    
-class OverviewView(QListView):
-    def __init__(self, connector):
-        QListView.__init__(self)
-        self.setModel(OverviewModel(self, connector))
-        
-        self.setAlternatingRowColors(True)
-        self.delegate = OverviewDelegate(self)
-        self.setItemDelegate(self.delegate)
-
-class OverviewDelegate(QItemDelegate):
-    def __init__(self, parent):
-        QItemDelegate.__init__(self, parent)
-        self.parent = parent
-        self.model = parent.model()
-    
-    def paint(self, painter, option, index):
-        option.rect.setHeight(59+16)
-        option.rect.setWidth(self.parent.width()-20)
-        
-        #if option.state & QStyle.State_Selected:
-        #    painter.fillRect(option.rect, option.palette.color(QPalette.Highlight))
-        
-        packagename = index.data(OverviewModel.PackageName).toString()
-        partsf = index.data(OverviewModel.PartsFinished).toString()
-        parts = index.data(OverviewModel.Parts).toString()
-        eta = int(index.data(OverviewModel.ETA).toString())
-        speed = index.data(OverviewModel.Speed).toString() or 0
-        progress = int(index.data(OverviewModel.Progress).toString())
-        currentSize = int(index.data(OverviewModel.CurrentSize).toString())
-        maxSize = int(index.data(OverviewModel.MaxSize).toString())
-        status = index.data(OverviewModel.Status).toString()
-        
-        def formatEta(seconds): #TODO add to utils
-            if seconds <= 0: return ""
-            hours, seconds = divmod(seconds, 3600)
-            minutes, seconds = divmod(seconds, 60)
-            return _("ETA: ") + "%.2i:%.2i:%.2i" % (hours, minutes, seconds)
-        
-        statusline = QString(_("Parts: ") + "%s/%s" % (partsf, parts))
-        if partsf == parts:
-            speedline = _("Finished")
-        elif not status == _("Downloading"):
-            speedline = QString(status)
-        else:
-            speedline = QString(formatEta(eta) + "     " + _("Speed: %s") % formatSpeed(speed))
-        
-        if progress in (0,100):
-            sizeline = QString(_("Size:") + "%s" % formatSize(maxSize))
-        else:
-            sizeline = QString(_("Size:") + "%s / %s" % (formatSize(currentSize), formatSize(maxSize)))
-        
-        f = painter.font()
-        f.setPointSize(12)
-        f.setBold(True)
-        painter.setFont(f)
-        
-        r = option.rect.adjusted(4, 4, -4, -4)
-        painter.drawText(r.left(), r.top(), r.width(), r.height(), Qt.AlignTop | Qt.AlignLeft, packagename)
-        newr = painter.boundingRect(r.left(), r.top(), r.width(), r.height(), Qt.AlignTop | Qt.AlignLeft, packagename)
-        
-        f.setPointSize(10)
-        f.setBold(False)
-        painter.setFont(f)
-        
-        painter.drawText(r.left(), newr.bottom()+5, r.width(), r.height(), Qt.AlignTop | Qt.AlignLeft, statusline)
-        painter.drawText(r.left(), newr.bottom()+5, r.width(), r.height(), Qt.AlignTop | Qt.AlignHCenter, sizeline)
-        painter.drawText(r.left(), newr.bottom()+5, r.width(), r.height(), Qt.AlignTop | Qt.AlignRight, speedline)
-        newr = painter.boundingRect(r.left(), newr.bottom()+2, r.width(), r.height(), Qt.AlignTop | Qt.AlignLeft, statusline)
-        newr.setTop(newr.bottom()+8)
-        newr.setBottom(newr.top()+20)
-        newr.setRight(self.parent.width()-25)
-        
-        f.setPointSize(10)
-        painter.setFont(f)
-        
-        opts = QStyleOptionProgressBarV2()
-        opts.maximum = 100
-        opts.minimum = 0
-        opts.progress = progress
-        opts.rect = newr
-        opts.textVisible = True
-        opts.textAlignment = Qt.AlignCenter
-        opts.text = QString.number(opts.progress) + "%"
-        QApplication.style().drawControl(QStyle.CE_ProgressBar, opts, painter)
-    
-    def sizeHint(self, option, index):
-        return QSize(self.parent.width()-22, 59+16)
diff --git a/module/gui/PackageDock.py b/module/gui/PackageDock.py
deleted file mode 100644
index 73db8f177..000000000
--- a/module/gui/PackageDock.py
+++ /dev/null
@@ -1,90 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    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/>.
-    
-    @author: mkaay
-"""
-import re
-
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
-
-class NewPackageDock(QDockWidget):
-    def __init__(self):
-        QDockWidget.__init__(self, _("New Package"))
-        self.setObjectName("New Package Dock")
-        self.widget = NewPackageWindow(self)
-        self.setWidget(self.widget)
-        self.setAllowedAreas(Qt.RightDockWidgetArea|Qt.LeftDockWidgetArea)
-        self.hide()
-    
-    def slotDone(self):
-        text = str(self.widget.box.toPlainText())
-        pw   = str(self.widget.passwordInput.text())
-        if not pw:
-            pw = None
-        lines = []
-        for line in text.splitlines():
-            line = line.strip()
-            if not line:
-                continue
-            lines.append(line)
-        self.emit(SIGNAL("done"), str(self.widget.nameInput.text()), lines, pw)
-        self.widget.nameInput.setText("")
-        self.widget.passwordInput.setText("")
-        self.widget.box.clear()
-        self.hide()
-
-    def parseUri(self):
-
-        text=str(self.widget.box.toPlainText())
-        self.widget.box.setText("")
-        result = re.findall(r"(?:ht|f)tps?:\/\/[a-zA-Z0-9\-\.\/\?=_&%#]+[<| |\"|\'|\r|\n|\t]{1}", text)
-        for url in result:
-            if "\n" or "\t" or "\r" or "\"" or "<" or "'" in url:
-                url = url[:-1]
-            self.widget.box.append("%s " % url)
-
-class NewPackageWindow(QWidget):
-    def __init__(self, dock):
-        QWidget.__init__(self)
-        self.dock = dock
-        self.setLayout(QGridLayout())
-        layout = self.layout()
-        
-        nameLabel = QLabel(_("Name"))
-        nameInput = QLineEdit()
-        passwordLabel = QLabel(_("Password"))
-        passwordInput = QLineEdit()
-        
-        linksLabel = QLabel(_("Links in this Package"))
-        
-        self.box = QTextEdit()
-        self.nameInput = nameInput
-        self.passwordInput = passwordInput
-        
-        save = QPushButton(_("Create"))
-        parseUri = QPushButton(_("Filter URLs"))
-        
-        layout.addWidget(nameLabel, 0, 0)
-        layout.addWidget(nameInput, 0, 1)
-        layout.addWidget(passwordLabel, 1, 0)
-        layout.addWidget(passwordInput, 1, 1)
-        layout.addWidget(linksLabel, 2, 0, 1, 2)
-        layout.addWidget(self.box, 3, 0, 1, 2)
-        layout.addWidget(parseUri, 4, 0, 1, 2)
-        layout.addWidget(save, 5, 0, 1, 2)
-
-        self.connect(save, SIGNAL("clicked()"), self.dock.slotDone)
-        self.connect(parseUri, SIGNAL("clicked()"), self.dock.parseUri)
\ No newline at end of file
diff --git a/module/gui/Queue.py b/module/gui/Queue.py
deleted file mode 100644
index 0a0cbb810..000000000
--- a/module/gui/Queue.py
+++ /dev/null
@@ -1,390 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    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/>.
-    
-    @author: mkaay
-"""
-
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
-
-from time import time
-
-from module.remote.thriftbackend.ThriftClient import Destination
-from module.gui.Collector import CollectorModel, Package, Link, CollectorView, statusMapReverse
-from module.utils import formatSize, formatSpeed
-
-class QueueModel(CollectorModel):
-    """
-        model for the queue view, inherits from CollectorModel
-    """
-    
-    def __init__(self, view, connector):
-        CollectorModel.__init__(self, view, connector)
-        self.cols = 6
-        self.wait_dict = {}
-        
-        self.updater = self.QueueUpdater(self.interval)
-        self.connect(self.updater, SIGNAL("update()"), self.update)
-    
-    class QueueUpdater(QObject):
-        """
-            timer which emits signal for a download status reload
-            @TODO: make intervall configurable
-        """
-        
-        def __init__(self, interval):
-            QObject.__init__(self)
-            
-            self.interval = interval
-            self.timer = QTimer()
-            self.timer.connect(self.timer, SIGNAL("timeout()"), self, SIGNAL("update()"))
-        
-        def start(self):
-            self.timer.start(1000)
-        
-        def stop(self):
-            self.timer.stop()
-    
-    def start(self):
-        self.updater.start()
-    
-    def stop(self):
-        self.updater.stop()
-    
-    def fullReload(self):
-        """
-            reimplements CollectorModel.fullReload, because we want the Queue data
-        """
-        self._data = []
-        order = self.connector.getPackageOrder(Destination.Queue)
-        self.beginInsertRows(QModelIndex(), 0, len(order.values()))
-        for position, pid in order.iteritems():
-            pack = self.connector.getPackageData(pid)
-            package = Package(pack)
-            self._data.append(package)
-        self._data = sorted(self._data, key=lambda p: p.data["order"])
-        self.endInsertRows()
-        self.updateCount()
-    
-    def insertEvent(self, event):
-        """
-            wrap CollectorModel.insertEvent to update the element count
-        """
-        CollectorModel.insertEvent(self, event)
-        self.updateCount()
-    
-    def removeEvent(self, event):
-        """
-            wrap CollectorModel.removeEvent to update the element count
-        """
-        CollectorModel.removeEvent(self, event)
-        self.updateCount()
-    
-    def updateEvent(self, event):
-        """
-            wrap CollectorModel.updateEvent to update the element count
-        """
-        CollectorModel.updateEvent(self, event)
-        self.updateCount()
-    
-    def updateCount(self):
-        """
-            calculate package- and filecount for statusbar,
-            ugly?: Overview connects to this signal for updating
-        """
-        packageCount = len(self._data)
-        fileCount = 0
-        for p in self._data:
-            fileCount += len(p.children)
-        self.mutex.unlock()
-        self.emit(SIGNAL("updateCount"), packageCount, fileCount)
-        self.mutex.lock()
-    
-    def update(self):
-        """
-            update slot for download status updating
-        """
-        locker = QMutexLocker(self.mutex)
-        downloading = self.connector.statusDownloads()
-        if not downloading:
-            return
-        for p, pack in enumerate(self._data):
-            for d in downloading:
-                child = pack.getChild(d.fid)
-                if child:
-                    dd = {
-                        "name": d.name,
-                        "speed": d.speed,
-                        "eta": d.eta,
-                        "format_eta": d.format_eta,
-                        "bleft": d.bleft,
-                        "size": d.size,
-                        "format_size": d.format_size,
-                        "percent": d.percent,
-                        "status": d.status,
-                        "statusmsg": d.statusmsg,
-                        "format_wait": d.format_wait,
-                        "wait_until": d.wait_until
-                    }
-                    child.data["downloading"] = dd
-                    k = pack.getChildKey(d.fid)
-                    self.emit(SIGNAL("dataChanged(const QModelIndex &, const QModelIndex &)"), self.index(k, 0, self.index(p, 0)), self.index(k, self.cols, self.index(p, self.cols)))
-        self.updateCount()
-                    
-    def headerData(self, section, orientation, role=Qt.DisplayRole):
-        """
-            returns column heading
-        """
-        if orientation == Qt.Horizontal and role == Qt.DisplayRole:
-            if section == 0:
-                return QVariant(_("Name"))
-            elif section == 2:
-                return QVariant(_("Status"))
-            elif section == 1:
-                return QVariant(_("Plugin"))
-            elif section == 3:
-                return QVariant(_("Size"))
-            elif section == 4:
-                return QVariant(_("ETA"))
-            elif section == 5:
-                return QVariant(_("Progress"))
-        return QVariant()
-    
-    def getWaitingProgress(self, item):
-        """
-            returns time to wait, caches startingtime to provide progress
-        """
-        locker = QMutexLocker(self.mutex)
-        if isinstance(item, Link):
-            if item.data["status"] == 5 and item.data["downloading"]:
-                until = float(item.data["downloading"]["wait_until"])
-                try:
-                    since, until_old = self.wait_dict[item.id]
-                    if not until == until_old:
-                        raise Exception
-                except:
-                    since = time()
-                    self.wait_dict[item.id] = since, until
-                since = float(since)
-                max_wait = float(until-since)
-                rest = int(until-time())
-                if rest < 0:
-                    return 0, None
-                res = 100/max_wait
-                perc = rest*res
-                return perc, rest
-        return None
-    
-    def getProgress(self, item, locked=True):
-        """
-            return download progress, locks by default
-            since it's used in already locked calls,
-            it provides an option to not lock
-        """
-        if locked:
-            locker = QMutexLocker(self.mutex)
-        if isinstance(item, Link):
-            try:
-                if item.data["status"] == 0:
-					return 100
-                return int(item.data["downloading"]["percent"])
-            except:
-                return 0
-        elif isinstance(item, Package):
-            count = len(item.children)
-            perc_sum = 0
-            for child in item.children:
-                try:
-                    if child.data["status"] == 0: #completed
-                        perc_sum += 100
-                    perc_sum += int(child.data["downloading"]["percent"])
-                except:
-                    pass
-            if count == 0:
-                return 0
-            return perc_sum/count
-        return 0
-    
-    def getSpeed(self, item):
-        """
-            calculate download speed
-        """
-        if isinstance(item, Link):
-            if item.data["downloading"]:
-                return int(item.data["downloading"]["speed"])
-        elif isinstance(item, Package):
-            count = len(item.children)
-            speed_sum = 0
-            all_waiting = True
-            running = False
-            for child in item.children:
-                val = 0
-                if child.data["downloading"]:
-                    if not child.data["statusmsg"] == "waiting":
-                        all_waiting = False
-                    val = int(child.data["downloading"]["speed"])
-                    running = True
-                speed_sum += val
-            if count == 0 or not running or all_waiting:
-                return None
-            return speed_sum
-        return None
-    
-    def data(self, index, role=Qt.DisplayRole):
-        """
-            return cell data
-        """
-        if not index.isValid():
-            return QVariant()
-        if role == Qt.DisplayRole:
-            if index.column() == 0:
-                return QVariant(index.internalPointer().data["name"])
-            elif index.column() == 1:
-                item = index.internalPointer()
-                plugins = []
-                if isinstance(item, Package):
-                    for child in item.children:
-                        if not child.data["plugin"] in plugins:
-                            plugins.append(child.data["plugin"])
-                else:
-                    plugins.append(item.data["plugin"])
-                return QVariant(", ".join(plugins))
-            elif index.column() == 2:
-                item = index.internalPointer()
-                status = 0
-                speed = self.getSpeed(item)
-                if isinstance(item, Package):
-                    for child in item.children:
-                        if child.data["status"] > status:
-                            status = child.data["status"]
-                else:
-                    status = item.data["status"]
-                
-                if speed is None or status == 7 or status == 10 or status == 5:
-                    return QVariant(self.translateStatus(statusMapReverse[status]))
-                else:
-                    return QVariant("%s (%s)" % (self.translateStatus(statusMapReverse[status]), formatSpeed(speed)))
-            elif index.column() == 3:
-                item = index.internalPointer()
-                if isinstance(item, Link):
-                    if item.data["status"] == 0: #TODO needs change??
-		            #self.getProgress(item, False) == 100:
-                        return QVariant(formatSize(item.data["size"]))
-                    elif self.getProgress(item, False) == 0:
-                        try:
-                            return QVariant("%s / %s" % (formatSize(item.data["size"]-item.data["downloading"]["bleft"]), formatSize(item.data["size"])))
-                        except:
-                            return QVariant("0 B / %s" % formatSize(item.data["size"]))
-                    else:
-                        try:
-                            return QVariant("%s / %s" % (formatSize(item.data["size"]-item.data["downloading"]["bleft"]), formatSize(item.data["size"])))
-                        except:
-                            return QVariant("? / %s" % formatSize(item.data["size"]))
-                else:
-                    ms = 0
-                    cs = 0
-                    for c in item.children:
-                        try:
-                            s = c.data["downloading"]["size"]
-                        except:
-                            s = c.data["size"]
-                        if c.data["downloading"]:
-                            cs += s - c.data["downloading"]["bleft"]
-                        elif self.getProgress(c, False) == 100:
-                            cs += s
-                        ms += s
-                    if cs == 0 or cs == ms:
-                        return QVariant(formatSize(ms))
-                    else:
-                        return QVariant("%s / %s" % (formatSize(cs), formatSize(ms)))
-            elif index.column() == 4:
-                item = index.internalPointer()
-                if isinstance(item, Link):
-                    if item.data["downloading"]:
-                        return QVariant(item.data["downloading"]["format_eta"])
-        elif role == Qt.EditRole:
-            if index.column() == 0:
-                return QVariant(index.internalPointer().data["name"])
-        return QVariant()
-    
-    def flags(self, index):
-        """
-            cell flags
-        """
-        if index.column() == 0 and self.parent(index) == QModelIndex():
-            return Qt.ItemIsSelectable | Qt.ItemIsEditable | Qt.ItemIsEnabled
-        return Qt.ItemIsSelectable | Qt.ItemIsEnabled
-    
-class QueueView(CollectorView):
-    """
-        view component for queue
-    """
-    
-    def __init__(self, connector):
-        CollectorView.__init__(self, connector)
-        self.setModel(QueueModel(self, connector))
-
-        self.setColumnWidth(0, 300)
-        self.setColumnWidth(1, 100)
-        self.setColumnWidth(2, 140)
-        self.setColumnWidth(3, 180)
-        self.setColumnWidth(4, 70)
-        
-        self.setEditTriggers(QAbstractItemView.NoEditTriggers)
-        
-        self.delegate = QueueProgressBarDelegate(self, self.model())
-        self.setItemDelegateForColumn(5, self.delegate)
-
-class QueueProgressBarDelegate(QItemDelegate):
-    """
-        used to display a progressbar in the progress cell
-    """
-    
-    def __init__(self, parent, queue):
-        QItemDelegate.__init__(self, parent)
-        self.queue = queue
-    
-    def paint(self, painter, option, index):
-        """
-            paint the progressbar
-        """
-        if not index.isValid():
-            return
-        if index.column() == 5:
-            item = index.internalPointer()
-            w = self.queue.getWaitingProgress(item)
-            wait = None
-            if w:
-                progress = w[0]
-                wait = w[1]
-            else:
-                progress = self.queue.getProgress(item)
-            opts = QStyleOptionProgressBarV2()
-            opts.maximum = 100
-            opts.minimum = 0
-            opts.progress = progress
-            opts.rect = option.rect
-            opts.rect.setRight(option.rect.right()-1)
-            opts.rect.setHeight(option.rect.height()-1)
-            opts.textVisible = True
-            opts.textAlignment = Qt.AlignCenter
-            if not wait is None:
-                opts.text = QString(_("waiting %d seconds") % (wait,))
-            else:
-                opts.text = QString.number(opts.progress) + "%"
-            QApplication.style().drawControl(QStyle.CE_ProgressBar, opts, painter)
-            return
-        QItemDelegate.paint(self, painter, option, index)
-
diff --git a/module/gui/SettingsWidget.py b/module/gui/SettingsWidget.py
deleted file mode 100644
index cd22a7b9e..000000000
--- a/module/gui/SettingsWidget.py
+++ /dev/null
@@ -1,202 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    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/>.
-    
-    @author: mkaay
-"""
-
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
-from sip import delete
-
-
-class SettingsWidget(QWidget):
-    def __init__(self):
-        QWidget.__init__(self)
-        self.connector = None
-        self.sections = {}
-        self.psections = {}
-        self.data = None
-        self.pdata = None
-        self.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
-    
-    def setConnector(self, connector):
-        self.connector = connector
-
-    def loadConfig(self):
-        if self.sections and self.psections:
-            self.data = self.connector.getConfig()
-            self.pdata = self.connector.getPluginConfig()
-
-            self.reloadSection(self.sections, self.data)
-            self.reloadSection(self.psections, self.pdata)
-
-            return
-
-        if self.layout():
-            delete(self.layout())
-
-        for s in self.sections.values()+self.psections.values():
-            delete(s)
-
-        self.sections = {}
-        self.setLayout(QVBoxLayout())
-        self.clearConfig()
-        layout = self.layout()
-        layout.setSizeConstraint(QLayout.SetMinAndMaxSize)
-
-        general = QTabWidget()
-        self.general = general
-
-        plugins = QTabWidget()
-        self.plugins = plugins
-
-        tab = QTabWidget()
-        self.tab = tab
-        
-        gw = QWidget()
-        gw.setLayout(QVBoxLayout())
-        gw.layout().addWidget(self.general)
-        pw = QWidget()
-        pw.setLayout(QVBoxLayout())
-        pw.layout().addWidget(self.plugins)
-        tab.addTab(gw, _("General"))
-        tab.addTab(pw, _("Plugins"))
-
-        layout.addWidget(tab)
-
-        self.data = self.connector.getConfig()
-        self.pdata = self.connector.getPluginConfig()
-        for k, section in self.data.iteritems():
-            s = Section(section, general)
-            self.sections[k] = s
-
-        for k, section in self.pdata.iteritems():
-            s = Section(section, plugins, "plugin")
-            self.psections[k] = s
-
-        rel = QPushButton(_("Reload"))
-        save = QPushButton(_("Save"))
-
-        layout.addWidget(save)
-
-        cont = QHBoxLayout()
-        cont.addWidget(rel)
-        cont.addWidget(save)
-
-        layout.addLayout(cont)
-
-        self.connect(save, SIGNAL("clicked()"), self.saveConfig)
-        self.connect(rel, SIGNAL("clicked()"), self.loadConfig)
-
-    def clearConfig(self):
-        self.sections = {}
-
-    def reloadSection(self, sections, pdata):
-
-        for k, section in enumerate(pdata):
-            if k in sections:
-                widget = sections[k]
-                for item in section.items:
-                    if item.name in widget.inputs:
-                        i = widget.inputs[item.name]
-
-                        if item.type == "int":
-                            i.setValue(int(item.value))
-                        elif not item.type.find(";") == -1:
-                            i.setCurrentIndex(i.findText(item.value))
-                        elif item.type == "bool":
-                            if True if item.value.lower() in ("1","true", "on", "an","yes") else False:
-                                i.setCurrentIndex(0)
-                            else:
-                                i.setCurrentIndex(1)
-                        else:
-                            i.setText(item.value)
-
-
-    def saveConfig(self):
-        self.data = self.connector.getConfig()
-        self.pdata = self.connector.getPluginConfig()
-
-        self.saveSection(self.sections, self.data)
-        self.saveSection(self.psections, self.pdata, "plugin")
-
-
-    def saveSection(self, sections, pdata, sec="core"):
-        for k, section in enumerate(pdata):
-            if k in sections:
-                widget = sections[k]
-                for item in section.items:
-                    if item.name in widget.inputs:
-                        i = widget.inputs[item.name]
-
-                        #TODO : unresolved reference: option
-
-                        if item.type == "int":
-                            if i.value() != int(item.value):
-                                self.connector.setConfigValue(k, option, i.value(), sec)
-                        elif not item.type.find(";") == -1:
-                            if i.currentText() != item.value:
-                                self.connector.setConfigValue(k, option, i.currentText(), sec)
-                        elif item.type == "bool":
-                            if (True if item.value.lower() in ("1","true", "on", "an","yes") else False) ^ (not i.currentIndex()):
-                                self.connector.setConfigValue(k, option, not i.currentIndex(), sec)
-                        else:
-                            if i.text() != item.value:
-                                self.connector.setConfigValue(k, option, str(i.text()), sec)
-
-class Section(QGroupBox):
-    def __init__(self, data, parent, ctype="core"):
-        self.data = data
-        QGroupBox.__init__(self, data.description, parent)
-        self.labels = {}
-        self.inputs = {}
-        self.ctype = ctype
-        layout = QFormLayout(self)
-        self.setLayout(layout)
-        
-        sw = QWidget()
-        sw.setLayout(QVBoxLayout())
-        sw.layout().addWidget(self)
-        
-        sa = QScrollArea()
-        sa.setWidgetResizable(True)
-        sa.setWidget(sw)
-        sa.setFrameShape(sa.NoFrame)
-        
-        parent.addTab(sa, data.description)
-        
-        for option in self.data.items:
-            if option.type == "int":
-                i = QSpinBox(self)
-                i.setMaximum(999999)
-                i.setValue(int(option.value))
-            elif not option.type.find(";") == -1:
-                choices = option.type.split(";")
-                i = QComboBox(self)
-                i.addItems(choices)
-                i.setCurrentIndex(i.findText(option.value))
-            elif option.type == "bool":
-                i = QComboBox(self)
-                i.addItem(_("Yes"), QVariant(True))
-                i.addItem(_("No"), QVariant(False))
-                if True if option.value.lower() in ("1","true", "on", "an","yes") else False:
-                    i.setCurrentIndex(0)
-                else:
-                    i.setCurrentIndex(1)
-            else:
-                i = QLineEdit(self)
-                i.setText(option.value)
-            layout.addRow(option.description, i)
-            layout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow)
diff --git a/module/gui/XMLParser.py b/module/gui/XMLParser.py
deleted file mode 100644
index 5e3b7bf65..000000000
--- a/module/gui/XMLParser.py
+++ /dev/null
@@ -1,71 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    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/>.
-    
-    @author: mkaay
-"""
-from __future__ import with_statement
-
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
-from PyQt4.QtXml import *
-
-import os
-
-class XMLParser():
-    def __init__(self, data, dfile=""):
-        self.mutex = QMutex()
-        self.mutex.lock()
-        self.xml = QDomDocument()
-        self.file = data
-        self.dfile = dfile
-        self.mutex.unlock()
-        self.loadData()
-        self.root = self.xml.documentElement()
-    
-    def loadData(self):
-        self.mutex.lock()
-        f = self.file
-        if not os.path.exists(f):
-            f = self.dfile
-        with open(f, 'r') as fh:
-            content = fh.read()
-        self.xml.setContent(content)
-        self.mutex.unlock()
-    
-    def saveData(self):
-        self.mutex.lock()
-        content = self.xml.toString()
-        with open(self.file, 'w') as fh:
-            fh.write(content)
-        self.mutex.unlock()
-        return content
-    
-    def parseNode(self, node, ret_type="list"):
-        if ret_type == "dict":
-            childNodes = {}
-        else:
-            childNodes = []
-        child = node.firstChild()
-        while True:
-            n = child.toElement()
-            if n.isNull():
-                break
-            else:
-                if ret_type == "dict":
-                    childNodes[str(n.tagName())] = n
-                else:
-                    childNodes.append(n)
-            child = child.nextSibling()
-        return childNodes
diff --git a/module/gui/__init__.py b/module/gui/__init__.py
deleted file mode 100644
index 8d1c8b69c..000000000
--- a/module/gui/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
- 
diff --git a/module/gui/connector.py b/module/gui/connector.py
deleted file mode 100644
index c16ccd08e..000000000
--- a/module/gui/connector.py
+++ /dev/null
@@ -1,165 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    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/>.
-    
-    @author: mkaay
-"""
-
-SERVER_VERSION = "0.4.9"
-
-from time import sleep
-from uuid import uuid4 as uuid
-
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
-
-import socket
-
-from module.remote.thriftbackend.ThriftClient import ThriftClient, WrongLogin, NoSSL, NoConnection
-from thrift.Thrift import TException
-
-class Connector(QObject):
-    """
-        manages the connection to the pyload core via thrift
-    """
-    
-    firstAttempt = True
-    
-    def __init__(self):
-        QObject.__init__(self)
-        self.mutex = QMutex()
-        self.connectionID = None
-        self.host = None
-        self.port = None
-        self.user = None
-        self.password = None
-        self.ssl = None
-        self.running = True
-        self.internal = False
-        self.proxy = self.Dummy()
-    
-    def setConnectionData(self, host, port, user, password, ssl=False):
-        """
-            set connection data for connection attempt, called from slotConnect
-        """
-        self.host = host
-        self.port = port
-        self.user = user
-        self.password = password
-        self.ssl = ssl
-    
-    def connectProxy(self):
-        """
-            initialize thrift rpc client,
-            check for ssl, check auth,
-            setup dispatcher,
-            connect error signals,
-            check server version
-        """
-        if self.internal: return True
-
-        err = None
-        try:
-            client = ThriftClient(self.host, self.port, self.user, self.password)
-        except WrongLogin:
-            err = _("bad login credentials")
-        except NoSSL:
-            err = _("no ssl support")
-        except NoConnection:
-            err = _("can't connect to host")
-        if err:
-            if not Connector.firstAttempt:
-                self.emit(SIGNAL("errorBox"), err)
-            Connector.firstAttempt = False
-            return False
-        
-        self.proxy = DispatchRPC(self.mutex, client)
-        self.connect(self.proxy, SIGNAL("connectionLost"), self, SIGNAL("connectionLost"))
-        
-        server_version = self.proxy.getServerVersion()
-        self.connectionID = uuid().hex
-        
-        if not server_version == SERVER_VERSION:
-            self.emit(SIGNAL("errorBox"), _("server is version %(new)s client accepts version %(current)s") % { "new": server_version, "current": SERVER_VERSION})
-            return False
-        
-        return True
-    
-    def __getattr__(self, attr):
-        """
-            redirect rpc calls to dispatcher
-        """
-        return getattr(self.proxy, attr)
-    
-    class Dummy(object):
-        """
-            dummy rpc proxy, to prevent errors
-        """
-        def __nonzero__(self):
-            return False
-
-        def __getattr__(self, attr):
-            def dummy(*args, **kwargs):
-                return None
-            return dummy
-
-class DispatchRPC(QObject):
-    """
-        wraps the thrift client, to catch critical exceptions (connection lost)
-        adds thread safety
-    """
-    
-    def __init__(self, mutex, server):
-        QObject.__init__(self)
-        self.mutex = mutex
-        self.server = server
-    
-    def __getattr__(self, attr):
-        """
-            redirect and wrap call in Wrapper instance, locks dispatcher
-        """
-        self.mutex.lock()
-        self.fname = attr
-        f = self.Wrapper(getattr(self.server, attr), self.mutex, self)
-        return f
-    
-    class Wrapper(object):
-        """
-            represents a rpc call
-        """
-        
-        def __init__(self, f, mutex, dispatcher):
-            self.f = f
-            self.mutex = mutex
-            self.dispatcher = dispatcher
-        
-        def __call__(self, *args, **kwargs):
-            """
-                instance is called, rpc is executed
-                exceptions are processed
-                finally dispatcher is unlocked
-            """
-            lost = False
-            try:
-                return self.f(*args, **kwargs)
-            except socket.error: #necessary?
-                lost = True
-            except TException:
-                lost = True
-            finally:
-                self.mutex.unlock()
-            if lost:
-                from traceback import print_exc
-                print_exc()
-                self.dispatcher.emit(SIGNAL("connectionLost"))
diff --git a/module/interaction/EventManager.py b/module/interaction/EventManager.py
new file mode 100644
index 000000000..b25514b6a
--- /dev/null
+++ b/module/interaction/EventManager.py
@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+
+from threading import Lock
+from traceback import print_exc
+
+class EventManager:
+    """
+    Handles all event-related tasks, also stores an event queue for clients, so they can retrieve them later.
+
+    **Known Events:**
+    Most addon methods exist as events. These are some additional known events.
+
+    ===================== ================ ===========================================================
+    Name                      Arguments      Description
+    ===================== ================ ===========================================================
+    event                 eventName, *args Called for every event, with eventName and original args
+    download:preparing    fid              A download was just queued and will be prepared now.
+    download:start        fid              A plugin will immediately start the download afterwards.
+    download:allProcessed                  All links were handled, pyLoad would idle afterwards.
+    download:allFinished                   All downloads in the queue are finished.
+    config:changed        sec, opt, value  The config was changed.
+    ===================== ================ ===========================================================
+
+    | Notes:
+    |    download:allProcessed is *always* called before download:allFinished.
+    """
+
+    def __init__(self, core):
+        self.core = core
+        self.log = core.log
+
+        # uuid : list of events
+        self.clients = {}
+        self.events = {"event": []}
+
+        self.lock = Lock()
+
+    def getEvents(self, uuid):
+        """ Get accumulated events for uuid since last call, this also registers a new client """
+        if uuid not in self.clients:
+            self.clients[uuid] = Client()
+        return self.clients[uuid].get()
+
+    def addEvent(self, event, func):
+        """Adds an event listener for event name"""
+        if event in self.events:
+            if func in self.events[event]:
+                self.log.debug("Function already registered %s" % func)
+            else:
+                self.events[event].append(func)
+        else:
+            self.events[event] = [func]
+
+    def removeEvent(self, event, func):
+        """removes previously added event listener"""
+        if event in self.events:
+            self.events[event].remove(func)
+
+    def dispatchEvent(self, event, *args):
+        """dispatches event with args"""
+        for f in self.events["event"]:
+            try:
+                f(event, *args)
+            except Exception, e:
+                self.log.warning("Error calling event handler %s: %s, %s, %s"
+                % ("event", f, args, str(e)))
+                if self.core.debug:
+                    print_exc()
+
+        if event in self.events:
+            for f in self.events[event]:
+                try:
+                    f(*args)
+                except Exception, e:
+                    self.log.warning("Error calling event handler %s: %s, %s, %s"
+                    % (event, f, args, str(e)))
+                    if self.core.debug:
+                        print_exc()
\ No newline at end of file
diff --git a/module/interaction/InteractionManager.py b/module/interaction/InteractionManager.py
new file mode 100644
index 000000000..e4ae05501
--- /dev/null
+++ b/module/interaction/InteractionManager.py
@@ -0,0 +1,166 @@
+# -*- coding: utf-8 -*-
+"""
+    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/>.
+
+    @author: RaNaN
+"""
+from threading import Lock
+from time import time
+from base64 import standard_b64encode
+
+from new_collections import OrderedDict
+
+from module.utils import lock, bits_set
+from module.Api import Interaction as IA
+from module.Api import InputType, Input
+
+from InteractionTask import InteractionTask
+
+class InteractionManager:
+    """
+    Class that gives ability to interact with the user.
+    Arbitrary tasks with predefined output and input types can be set off.
+    """
+
+    # number of seconds a client is classified as active
+    CLIENT_THRESHOLD = 60
+    NOTIFICATION_TIMEOUT = 60 * 60 * 30
+    MAX_NOTIFICATIONS = 50
+
+    def __init__(self, core):
+        self.lock = Lock()
+        self.core = core
+        self.tasks = OrderedDict() #task store, for all outgoing tasks
+
+        self.last_clients = {}
+        self.ids = 0 #uniue interaction ids
+
+    def isClientConnected(self, user):
+        return self.last_clients.get(user, 0) + self.CLIENT_THRESHOLD > time()
+
+    @lock
+    def work(self):
+        # old notifications will be removed
+        for n in [k for k, v in self.tasks.iteritems() if v.timedOut()]:
+            del self.tasks[n]
+
+        # keep notifications count limited
+        n = [k for k,v in self.tasks.iteritems() if v.type == IA.Notification]
+        n.reverse()
+        for v in n[:self.MAX_NOTIFICATIONS]:
+            del self.tasks[v]
+
+    @lock
+    def createNotification(self, title, content, desc="", plugin="", owner=None):
+        """ Creates and queues a new Notification
+
+        :param title: short title
+        :param content: text content
+        :param desc: short form of the notification
+        :param plugin: plugin name
+        :return: :class:`InteractionTask`
+        """
+        task = InteractionTask(self.ids, IA.Notification, Input(InputType.Text, content), "", title, desc, plugin,
+                               owner=owner)
+        self.ids += 1
+        self.queueTask(task)
+        return task
+
+    @lock
+    def createQueryTask(self, input, desc, default="", plugin="", owner=None):
+        # input type was given, create a input widget
+        if type(input) == int:
+            input = Input(input)
+        if not isinstance(input, Input):
+            raise TypeError("'Input' class expected not '%s'" % type(input))
+
+        task = InteractionTask(self.ids, IA.Query, input, default, _("Query"), desc, plugin, owner=owner)
+        self.ids += 1
+        self.queueTask(task)
+        return task
+
+    @lock
+    def createCaptchaTask(self, img, format, filename, plugin="", type=InputType.Text, owner=None):
+        """ Createss a new captcha task.
+
+        :param img: image content (not base encoded)
+        :param format: img format
+        :param type: :class:`InputType`
+        :return:
+        """
+        if type == 'textual':
+            type = InputType.Text
+        elif type == 'positional':
+            type = InputType.Click
+
+        input = Input(type, [standard_b64encode(img), format, filename])
+
+        #todo: title desc plugin
+        task = InteractionTask(self.ids, IA.Captcha, input,
+                               None, _("Captcha request"), _("Please solve the captcha."), plugin, owner=owner)
+
+        self.ids += 1
+        self.queueTask(task)
+        return task
+
+    @lock
+    def removeTask(self, task):
+        if task.iid in self.tasks:
+            del self.tasks[task.iid]
+            self.core.evm.dispatchEvent("interaction:deleted", task.iid)
+
+    @lock
+    def getTaskByID(self, iid):
+        return self.tasks.get(iid, None)
+
+    @lock
+    def getTasks(self, user, mode=IA.All):
+        # update last active clients
+        self.last_clients[user] = time()
+
+        # filter current mode
+        tasks = [t for t in self.tasks.itervalues() if mode == IA.All or bits_set(t.type, mode)]
+        # filter correct user / or shared
+        tasks = [t for t in tasks if user is None or user == t.owner or t.shared]
+
+        return tasks
+
+    def isTaskWaiting(self, user, mode=IA.All):
+        tasks = [t for t in self.getTasks(user, mode) if not t.type == IA.Notification or not t.seen]
+        return len(tasks) > 0
+
+    def queueTask(self, task):
+        cli = self.isClientConnected(task.owner)
+
+        # set waiting times based on threshold
+        if cli:
+            task.setWaiting(self.CLIENT_THRESHOLD)
+        else: # TODO: higher threshold after client connects?
+            task.setWaiting(self.CLIENT_THRESHOLD / 3)
+
+        if task.type == IA.Notification:
+            task.setWaiting(self.NOTIFICATION_TIMEOUT) # notifications are valid for 30h
+
+        for plugin in self.core.addonManager.activePlugins():
+            try:
+                plugin.newInteractionTask(task)
+            except:
+                self.core.print_exc()
+
+        self.tasks[task.iid] = task
+        self.core.evm.dispatchEvent("interaction:added", task)
+
+
+if __name__ == "__main__":
+    it = InteractionTask()
\ No newline at end of file
diff --git a/module/interaction/InteractionTask.py b/module/interaction/InteractionTask.py
new file mode 100644
index 000000000..d2877b2b0
--- /dev/null
+++ b/module/interaction/InteractionTask.py
@@ -0,0 +1,100 @@
+# -*- coding: utf-8 -*-
+"""
+    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/>.
+
+    @author: RaNaN
+"""
+
+from time import time
+
+from module.Api import InteractionTask as BaseInteractionTask
+from module.Api import Interaction, InputType, Input
+
+#noinspection PyUnresolvedReferences
+class InteractionTask(BaseInteractionTask):
+    """
+    General Interaction Task extends ITask defined by api with additional fields and methods.
+    """
+    #: Plugins can put needed data here
+    storage = None
+    #: Timestamp when task expires
+    wait_until = 0
+    #: The received result
+    result = None
+    #: List of registered handles
+    handler = None
+    #: Error Message
+    error = None
+    #: Timeout locked
+    locked = False
+    #: A task that was retrieved counts as seen
+    seen = False
+    #: A task that is relevant to every user
+    shared = False
+    #: primary uid of the owner
+    owner = None
+
+    def __init__(self, *args, **kwargs):
+        if 'owner' in kwargs:
+            self.owner = kwargs['owner']
+            del kwargs['owner']
+        if 'shared' in kwargs:
+            self.shared = kwargs['shared']
+            del kwargs['shared']
+
+        BaseInteractionTask.__init__(self, *args, **kwargs)
+
+        # additional internal attributes
+        self.storage = {}
+        self.handler = []
+        self.wait_until = 0
+
+    def convertResult(self, value):
+        #TODO: convert based on input/output
+        return value
+
+    def getResult(self):
+        return self.result
+
+    def setShared(self):
+        """ enable shared mode, should not be reversed"""
+        self.shared = True
+
+    def setResult(self, value):
+        self.result = self.convertResult(value)
+
+    def setWaiting(self, sec, lock=False):
+        """ sets waiting in seconds from now, < 0 can be used as infinitive  """
+        if not self.locked:
+            if sec < 0:
+                self.wait_until = -1
+            else:
+                self.wait_until = max(time() + sec, self.wait_until)
+
+            if lock: self.locked = True
+
+    def isWaiting(self):
+        if self.result or self.error or self.timedOut():
+            return False
+
+        return True
+
+    def timedOut(self):
+        return time() > self.wait_until > -1
+
+    def correct(self):
+        [x.taskCorrect(self) for x in self.handler]
+
+    def invalid(self):
+        [x.taskInvalid(self) for x in self.handler]
\ No newline at end of file
diff --git a/module/remote/socketbackend/__init__.py b/module/interaction/__init__.py
index de6d13128..de6d13128 100644
--- a/module/remote/socketbackend/__init__.py
+++ b/module/interaction/__init__.py
diff --git a/module/lib/BeautifulSoup.py b/module/lib/BeautifulSoup.py
deleted file mode 100644
index 55567f588..000000000
--- a/module/lib/BeautifulSoup.py
+++ /dev/null
@@ -1,2012 +0,0 @@
-"""Beautiful Soup
-Elixir and Tonic
-"The Screen-Scraper's Friend"
-http://www.crummy.com/software/BeautifulSoup/
-
-Beautiful Soup parses a (possibly invalid) XML or HTML document into a
-tree representation. It provides methods and Pythonic idioms that make
-it easy to navigate, search, and modify the tree.
-
-A well-formed XML/HTML document yields a well-formed data
-structure. An ill-formed XML/HTML document yields a correspondingly
-ill-formed data structure. If your document is only locally
-well-formed, you can use this library to find and process the
-well-formed part of it.
-
-Beautiful Soup works with Python 2.2 and up. It has no external
-dependencies, but you'll have more success at converting data to UTF-8
-if you also install these three packages:
-
-* chardet, for auto-detecting character encodings
-  http://chardet.feedparser.org/
-* cjkcodecs and iconv_codec, which add more encodings to the ones supported
-  by stock Python.
-  http://cjkpython.i18n.org/
-
-Beautiful Soup defines classes for two main parsing strategies:
-
- * BeautifulStoneSoup, for parsing XML, SGML, or your domain-specific
-   language that kind of looks like XML.
-
- * BeautifulSoup, for parsing run-of-the-mill HTML code, be it valid
-   or invalid. This class has web browser-like heuristics for
-   obtaining a sensible parse tree in the face of common HTML errors.
-
-Beautiful Soup also defines a class (UnicodeDammit) for autodetecting
-the encoding of an HTML or XML document, and converting it to
-Unicode. Much of this code is taken from Mark Pilgrim's Universal Feed Parser.
-
-For more than you ever wanted to know about Beautiful Soup, see the
-documentation:
-http://www.crummy.com/software/BeautifulSoup/documentation.html
-
-Here, have some legalese:
-
-Copyright (c) 2004-2010, Leonard Richardson
-
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-  * Redistributions of source code must retain the above copyright
-    notice, this list of conditions and the following disclaimer.
-
-  * Redistributions in binary form must reproduce the above
-    copyright notice, this list of conditions and the following
-    disclaimer in the documentation and/or other materials provided
-    with the distribution.
-
-  * Neither the name of the the Beautiful Soup Consortium and All
-    Night Kosher Bakery nor the names of its contributors may be
-    used to endorse or promote products derived from this software
-    without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
-CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE, DAMMIT.
-
-"""
-from __future__ import generators
-
-__author__ = "Leonard Richardson (leonardr@segfault.org)"
-__version__ = "3.0.8.1"
-__copyright__ = "Copyright (c) 2004-2010 Leonard Richardson"
-__license__ = "New-style BSD"
-
-from sgmllib import SGMLParser, SGMLParseError
-import codecs
-import markupbase
-import types
-import re
-import sgmllib
-try:
-  from htmlentitydefs import name2codepoint
-except ImportError:
-  name2codepoint = {}
-try:
-    set
-except NameError:
-    from sets import Set as set
-
-#These hacks make Beautiful Soup able to parse XML with namespaces
-sgmllib.tagfind = re.compile('[a-zA-Z][-_.:a-zA-Z0-9]*')
-markupbase._declname_match = re.compile(r'[a-zA-Z][-_.:a-zA-Z0-9]*\s*').match
-
-DEFAULT_OUTPUT_ENCODING = "utf-8"
-
-def _match_css_class(str):
-    """Build a RE to match the given CSS class."""
-    return re.compile(r"(^|.*\s)%s($|\s)" % str)
-
-# First, the classes that represent markup elements.
-
-class PageElement(object):
-    """Contains the navigational information for some part of the page
-    (either a tag or a piece of text)"""
-
-    def setup(self, parent=None, previous=None):
-        """Sets up the initial relations between this element and
-        other elements."""
-        self.parent = parent
-        self.previous = previous
-        self.next = None
-        self.previousSibling = None
-        self.nextSibling = None
-        if self.parent and self.parent.contents:
-            self.previousSibling = self.parent.contents[-1]
-            self.previousSibling.nextSibling = self
-
-    def replaceWith(self, replaceWith):
-        oldParent = self.parent
-        myIndex = self.parent.index(self)
-        if hasattr(replaceWith, "parent")\
-                  and replaceWith.parent is self.parent:
-            # We're replacing this element with one of its siblings.
-            index = replaceWith.parent.index(replaceWith)
-            if index and index < myIndex:
-                # Furthermore, it comes before this element. That
-                # means that when we extract it, the index of this
-                # element will change.
-                myIndex = myIndex - 1
-        self.extract()
-        oldParent.insert(myIndex, replaceWith)
-
-    def replaceWithChildren(self):
-        myParent = self.parent
-        myIndex = self.parent.index(self)
-        self.extract()
-        reversedChildren = list(self.contents)
-        reversedChildren.reverse()
-        for child in reversedChildren:
-            myParent.insert(myIndex, child)
-
-    def extract(self):
-        """Destructively rips this element out of the tree."""
-        if self.parent:
-            try:
-                del self.parent.contents[self.parent.index(self)]
-            except ValueError:
-                pass
-
-        #Find the two elements that would be next to each other if
-        #this element (and any children) hadn't been parsed. Connect
-        #the two.
-        lastChild = self._lastRecursiveChild()
-        nextElement = lastChild.next
-
-        if self.previous:
-            self.previous.next = nextElement
-        if nextElement:
-            nextElement.previous = self.previous
-        self.previous = None
-        lastChild.next = None
-
-        self.parent = None
-        if self.previousSibling:
-            self.previousSibling.nextSibling = self.nextSibling
-        if self.nextSibling:
-            self.nextSibling.previousSibling = self.previousSibling
-        self.previousSibling = self.nextSibling = None
-        return self
-
-    def _lastRecursiveChild(self):
-        "Finds the last element beneath this object to be parsed."
-        lastChild = self
-        while hasattr(lastChild, 'contents') and lastChild.contents:
-            lastChild = lastChild.contents[-1]
-        return lastChild
-
-    def insert(self, position, newChild):
-        if isinstance(newChild, basestring) \
-            and not isinstance(newChild, NavigableString):
-            newChild = NavigableString(newChild)
-
-        position =  min(position, len(self.contents))
-        if hasattr(newChild, 'parent') and newChild.parent is not None:
-            # We're 'inserting' an element that's already one
-            # of this object's children.
-            if newChild.parent is self:
-                index = self.index(newChild)
-                if index > position:
-                    # Furthermore we're moving it further down the
-                    # list of this object's children. That means that
-                    # when we extract this element, our target index
-                    # will jump down one.
-                    position = position - 1
-            newChild.extract()
-
-        newChild.parent = self
-        previousChild = None
-        if position == 0:
-            newChild.previousSibling = None
-            newChild.previous = self
-        else:
-            previousChild = self.contents[position-1]
-            newChild.previousSibling = previousChild
-            newChild.previousSibling.nextSibling = newChild
-            newChild.previous = previousChild._lastRecursiveChild()
-        if newChild.previous:
-            newChild.previous.next = newChild
-
-        newChildsLastElement = newChild._lastRecursiveChild()
-
-        if position >= len(self.contents):
-            newChild.nextSibling = None
-
-            parent = self
-            parentsNextSibling = None
-            while not parentsNextSibling:
-                parentsNextSibling = parent.nextSibling
-                parent = parent.parent
-                if not parent: # This is the last element in the document.
-                    break
-            if parentsNextSibling:
-                newChildsLastElement.next = parentsNextSibling
-            else:
-                newChildsLastElement.next = None
-        else:
-            nextChild = self.contents[position]
-            newChild.nextSibling = nextChild
-            if newChild.nextSibling:
-                newChild.nextSibling.previousSibling = newChild
-            newChildsLastElement.next = nextChild
-
-        if newChildsLastElement.next:
-            newChildsLastElement.next.previous = newChildsLastElement
-        self.contents.insert(position, newChild)
-
-    def append(self, tag):
-        """Appends the given tag to the contents of this tag."""
-        self.insert(len(self.contents), tag)
-
-    def findNext(self, name=None, attrs={}, text=None, **kwargs):
-        """Returns the first item that matches the given criteria and
-        appears after this Tag in the document."""
-        return self._findOne(self.findAllNext, name, attrs, text, **kwargs)
-
-    def findAllNext(self, name=None, attrs={}, text=None, limit=None,
-                    **kwargs):
-        """Returns all items that match the given criteria and appear
-        after this Tag in the document."""
-        return self._findAll(name, attrs, text, limit, self.nextGenerator,
-                             **kwargs)
-
-    def findNextSibling(self, name=None, attrs={}, text=None, **kwargs):
-        """Returns the closest sibling to this Tag that matches the
-        given criteria and appears after this Tag in the document."""
-        return self._findOne(self.findNextSiblings, name, attrs, text,
-                             **kwargs)
-
-    def findNextSiblings(self, name=None, attrs={}, text=None, limit=None,
-                         **kwargs):
-        """Returns the siblings of this Tag that match the given
-        criteria and appear after this Tag in the document."""
-        return self._findAll(name, attrs, text, limit,
-                             self.nextSiblingGenerator, **kwargs)
-    fetchNextSiblings = findNextSiblings # Compatibility with pre-3.x
-
-    def findPrevious(self, name=None, attrs={}, text=None, **kwargs):
-        """Returns the first item that matches the given criteria and
-        appears before this Tag in the document."""
-        return self._findOne(self.findAllPrevious, name, attrs, text, **kwargs)
-
-    def findAllPrevious(self, name=None, attrs={}, text=None, limit=None,
-                        **kwargs):
-        """Returns all items that match the given criteria and appear
-        before this Tag in the document."""
-        return self._findAll(name, attrs, text, limit, self.previousGenerator,
-                           **kwargs)
-    fetchPrevious = findAllPrevious # Compatibility with pre-3.x
-
-    def findPreviousSibling(self, name=None, attrs={}, text=None, **kwargs):
-        """Returns the closest sibling to this Tag that matches the
-        given criteria and appears before this Tag in the document."""
-        return self._findOne(self.findPreviousSiblings, name, attrs, text,
-                             **kwargs)
-
-    def findPreviousSiblings(self, name=None, attrs={}, text=None,
-                             limit=None, **kwargs):
-        """Returns the siblings of this Tag that match the given
-        criteria and appear before this Tag in the document."""
-        return self._findAll(name, attrs, text, limit,
-                             self.previousSiblingGenerator, **kwargs)
-    fetchPreviousSiblings = findPreviousSiblings # Compatibility with pre-3.x
-
-    def findParent(self, name=None, attrs={}, **kwargs):
-        """Returns the closest parent of this Tag that matches the given
-        criteria."""
-        # NOTE: We can't use _findOne because findParents takes a different
-        # set of arguments.
-        r = None
-        l = self.findParents(name, attrs, 1)
-        if l:
-            r = l[0]
-        return r
-
-    def findParents(self, name=None, attrs={}, limit=None, **kwargs):
-        """Returns the parents of this Tag that match the given
-        criteria."""
-
-        return self._findAll(name, attrs, None, limit, self.parentGenerator,
-                             **kwargs)
-    fetchParents = findParents # Compatibility with pre-3.x
-
-    #These methods do the real heavy lifting.
-
-    def _findOne(self, method, name, attrs, text, **kwargs):
-        r = None
-        l = method(name, attrs, text, 1, **kwargs)
-        if l:
-            r = l[0]
-        return r
-
-    def _findAll(self, name, attrs, text, limit, generator, **kwargs):
-        "Iterates over a generator looking for things that match."
-
-        if isinstance(name, SoupStrainer):
-            strainer = name
-        # (Possibly) special case some findAll*(...) searches
-        elif text is None and not limit and not attrs and not kwargs:
-            # findAll*(True)
-            if name is True:
-                return [element for element in generator()
-                        if isinstance(element, Tag)]
-            # findAll*('tag-name')
-            elif isinstance(name, basestring):
-                return [element for element in generator()
-                        if isinstance(element, Tag) and
-                        element.name == name]
-            else:
-                strainer = SoupStrainer(name, attrs, text, **kwargs)
-        # Build a SoupStrainer
-        else:
-            strainer = SoupStrainer(name, attrs, text, **kwargs)
-        results = ResultSet(strainer)
-        g = generator()
-        while True:
-            try:
-                i = g.next()
-            except StopIteration:
-                break
-            if i:
-                found = strainer.search(i)
-                if found:
-                    results.append(found)
-                    if limit and len(results) >= limit:
-                        break
-        return results
-
-    #These Generators can be used to navigate starting from both
-    #NavigableStrings and Tags.
-    def nextGenerator(self):
-        i = self
-        while i is not None:
-            i = i.next
-            yield i
-
-    def nextSiblingGenerator(self):
-        i = self
-        while i is not None:
-            i = i.nextSibling
-            yield i
-
-    def previousGenerator(self):
-        i = self
-        while i is not None:
-            i = i.previous
-            yield i
-
-    def previousSiblingGenerator(self):
-        i = self
-        while i is not None:
-            i = i.previousSibling
-            yield i
-
-    def parentGenerator(self):
-        i = self
-        while i is not None:
-            i = i.parent
-            yield i
-
-    # Utility methods
-    def substituteEncoding(self, str, encoding=None):
-        encoding = encoding or "utf-8"
-        return str.replace("%SOUP-ENCODING%", encoding)
-
-    def toEncoding(self, s, encoding=None):
-        """Encodes an object to a string in some encoding, or to Unicode.
-        ."""
-        if isinstance(s, unicode):
-            if encoding:
-                s = s.encode(encoding)
-        elif isinstance(s, str):
-            if encoding:
-                s = s.encode(encoding)
-            else:
-                s = unicode(s)
-        else:
-            if encoding:
-                s  = self.toEncoding(str(s), encoding)
-            else:
-                s = unicode(s)
-        return s
-
-class NavigableString(unicode, PageElement):
-
-    def __new__(cls, value):
-        """Create a new NavigableString.
-
-        When unpickling a NavigableString, this method is called with
-        the string in DEFAULT_OUTPUT_ENCODING. That encoding needs to be
-        passed in to the superclass's __new__ or the superclass won't know
-        how to handle non-ASCII characters.
-        """
-        if isinstance(value, unicode):
-            return unicode.__new__(cls, value)
-        return unicode.__new__(cls, value, DEFAULT_OUTPUT_ENCODING)
-
-    def __getnewargs__(self):
-        return (NavigableString.__str__(self),)
-
-    def __getattr__(self, attr):
-        """text.string gives you text. This is for backwards
-        compatibility for Navigable*String, but for CData* it lets you
-        get the string without the CData wrapper."""
-        if attr == 'string':
-            return self
-        else:
-            raise AttributeError, "'%s' object has no attribute '%s'" % (self.__class__.__name__, attr)
-
-    def __unicode__(self):
-        return str(self).decode(DEFAULT_OUTPUT_ENCODING)
-
-    def __str__(self, encoding=DEFAULT_OUTPUT_ENCODING):
-        if encoding:
-            return self.encode(encoding)
-        else:
-            return self
-
-class CData(NavigableString):
-
-    def __str__(self, encoding=DEFAULT_OUTPUT_ENCODING):
-        return "<![CDATA[%s]]>" % NavigableString.__str__(self, encoding)
-
-class ProcessingInstruction(NavigableString):
-    def __str__(self, encoding=DEFAULT_OUTPUT_ENCODING):
-        output = self
-        if "%SOUP-ENCODING%" in output:
-            output = self.substituteEncoding(output, encoding)
-        return "<?%s?>" % self.toEncoding(output, encoding)
-
-class Comment(NavigableString):
-    def __str__(self, encoding=DEFAULT_OUTPUT_ENCODING):
-        return "<!--%s-->" % NavigableString.__str__(self, encoding)
-
-class Declaration(NavigableString):
-    def __str__(self, encoding=DEFAULT_OUTPUT_ENCODING):
-        return "<!%s>" % NavigableString.__str__(self, encoding)
-
-class Tag(PageElement):
-
-    """Represents a found HTML tag with its attributes and contents."""
-
-    def _invert(h):
-        "Cheap function to invert a hash."
-        i = {}
-        for k,v in h.items():
-            i[v] = k
-        return i
-
-    XML_ENTITIES_TO_SPECIAL_CHARS = { "apos" : "'",
-                                      "quot" : '"',
-                                      "amp" : "&",
-                                      "lt" : "<",
-                                      "gt" : ">" }
-
-    XML_SPECIAL_CHARS_TO_ENTITIES = _invert(XML_ENTITIES_TO_SPECIAL_CHARS)
-
-    def _convertEntities(self, match):
-        """Used in a call to re.sub to replace HTML, XML, and numeric
-        entities with the appropriate Unicode characters. If HTML
-        entities are being converted, any unrecognized entities are
-        escaped."""
-        x = match.group(1)
-        if self.convertHTMLEntities and x in name2codepoint:
-            return unichr(name2codepoint[x])
-        elif x in self.XML_ENTITIES_TO_SPECIAL_CHARS:
-            if self.convertXMLEntities:
-                return self.XML_ENTITIES_TO_SPECIAL_CHARS[x]
-            else:
-                return u'&%s;' % x
-        elif len(x) > 0 and x[0] == '#':
-            # Handle numeric entities
-            if len(x) > 1 and x[1] == 'x':
-                return unichr(int(x[2:], 16))
-            else:
-                return unichr(int(x[1:]))
-
-        elif self.escapeUnrecognizedEntities:
-            return u'&amp;%s;' % x
-        else:
-            return u'&%s;' % x
-
-    def __init__(self, parser, name, attrs=None, parent=None,
-                 previous=None):
-        "Basic constructor."
-
-        # We don't actually store the parser object: that lets extracted
-        # chunks be garbage-collected
-        self.parserClass = parser.__class__
-        self.isSelfClosing = parser.isSelfClosingTag(name)
-        self.name = name
-        if attrs is None:
-            attrs = []
-        self.attrs = attrs
-        self.contents = []
-        self.setup(parent, previous)
-        self.hidden = False
-        self.containsSubstitutions = False
-        self.convertHTMLEntities = parser.convertHTMLEntities
-        self.convertXMLEntities = parser.convertXMLEntities
-        self.escapeUnrecognizedEntities = parser.escapeUnrecognizedEntities
-
-        # Convert any HTML, XML, or numeric entities in the attribute values.
-        convert = lambda(k, val): (k,
-                                   re.sub("&(#\d+|#x[0-9a-fA-F]+|\w+);",
-                                          self._convertEntities,
-                                          val))
-        self.attrs = map(convert, self.attrs)
-
-    def getString(self):
-        if (len(self.contents) == 1
-            and isinstance(self.contents[0], NavigableString)):
-            return self.contents[0]
-
-    def setString(self, string):
-        """Replace the contents of the tag with a string"""
-        self.clear()
-        self.append(string)
-
-    string = property(getString, setString)
-
-    def getText(self, separator=u""):
-        if not len(self.contents):
-            return u""
-        stopNode = self._lastRecursiveChild().next
-        strings = []
-        current = self.contents[0]
-        while current is not stopNode:
-            if isinstance(current, NavigableString):
-                strings.append(current.strip())
-            current = current.next
-        return separator.join(strings)
-
-    text = property(getText)
-
-    def get(self, key, default=None):
-        """Returns the value of the 'key' attribute for the tag, or
-        the value given for 'default' if it doesn't have that
-        attribute."""
-        return self._getAttrMap().get(key, default)
-
-    def clear(self):
-        """Extract all children."""
-        for child in self.contents[:]:
-            child.extract()
-
-    def index(self, element):
-        for i, child in enumerate(self.contents):
-            if child is element:
-                return i
-        raise ValueError("Tag.index: element not in tag")
-
-    def has_key(self, key):
-        return self._getAttrMap().has_key(key)
-
-    def __getitem__(self, key):
-        """tag[key] returns the value of the 'key' attribute for the tag,
-        and throws an exception if it's not there."""
-        return self._getAttrMap()[key]
-
-    def __iter__(self):
-        "Iterating over a tag iterates over its contents."
-        return iter(self.contents)
-
-    def __len__(self):
-        "The length of a tag is the length of its list of contents."
-        return len(self.contents)
-
-    def __contains__(self, x):
-        return x in self.contents
-
-    def __nonzero__(self):
-        "A tag is non-None even if it has no contents."
-        return True
-
-    def __setitem__(self, key, value):
-        """Setting tag[key] sets the value of the 'key' attribute for the
-        tag."""
-        self._getAttrMap()
-        self.attrMap[key] = value
-        found = False
-        for i in range(0, len(self.attrs)):
-            if self.attrs[i][0] == key:
-                self.attrs[i] = (key, value)
-                found = True
-        if not found:
-            self.attrs.append((key, value))
-        self._getAttrMap()[key] = value
-
-    def __delitem__(self, key):
-        "Deleting tag[key] deletes all 'key' attributes for the tag."
-        for item in self.attrs:
-            if item[0] == key:
-                self.attrs.remove(item)
-                #We don't break because bad HTML can define the same
-                #attribute multiple times.
-            self._getAttrMap()
-            if self.attrMap.has_key(key):
-                del self.attrMap[key]
-
-    def __call__(self, *args, **kwargs):
-        """Calling a tag like a function is the same as calling its
-        findAll() method. Eg. tag('a') returns a list of all the A tags
-        found within this tag."""
-        return apply(self.findAll, args, kwargs)
-
-    def __getattr__(self, tag):
-        #print "Getattr %s.%s" % (self.__class__, tag)
-        if len(tag) > 3 and tag.rfind('Tag') == len(tag)-3:
-            return self.find(tag[:-3])
-        elif tag.find('__') != 0:
-            return self.find(tag)
-        raise AttributeError, "'%s' object has no attribute '%s'" % (self.__class__, tag)
-
-    def __eq__(self, other):
-        """Returns true iff this tag has the same name, the same attributes,
-        and the same contents (recursively) as the given tag.
-
-        NOTE: right now this will return false if two tags have the
-        same attributes in a different order. Should this be fixed?"""
-        if other is self:
-            return True
-        if not hasattr(other, 'name') or not hasattr(other, 'attrs') or not hasattr(other, 'contents') or self.name != other.name or self.attrs != other.attrs or len(self) != len(other):
-            return False
-        for i in range(0, len(self.contents)):
-            if self.contents[i] != other.contents[i]:
-                return False
-        return True
-
-    def __ne__(self, other):
-        """Returns true iff this tag is not identical to the other tag,
-        as defined in __eq__."""
-        return not self == other
-
-    def __repr__(self, encoding=DEFAULT_OUTPUT_ENCODING):
-        """Renders this tag as a string."""
-        return self.__str__(encoding)
-
-    def __unicode__(self):
-        return self.__str__(None)
-
-    BARE_AMPERSAND_OR_BRACKET = re.compile("([<>]|"
-                                           + "&(?!#\d+;|#x[0-9a-fA-F]+;|\w+;)"
-                                           + ")")
-
-    def _sub_entity(self, x):
-        """Used with a regular expression to substitute the
-        appropriate XML entity for an XML special character."""
-        return "&" + self.XML_SPECIAL_CHARS_TO_ENTITIES[x.group(0)[0]] + ";"
-
-    def __str__(self, encoding=DEFAULT_OUTPUT_ENCODING,
-                prettyPrint=False, indentLevel=0):
-        """Returns a string or Unicode representation of this tag and
-        its contents. To get Unicode, pass None for encoding.
-
-        NOTE: since Python's HTML parser consumes whitespace, this
-        method is not certain to reproduce the whitespace present in
-        the original string."""
-
-        encodedName = self.toEncoding(self.name, encoding)
-
-        attrs = []
-        if self.attrs:
-            for key, val in self.attrs:
-                fmt = '%s="%s"'
-                if isinstance(val, basestring):
-                    if self.containsSubstitutions and '%SOUP-ENCODING%' in val:
-                        val = self.substituteEncoding(val, encoding)
-
-                    # The attribute value either:
-                    #
-                    # * Contains no embedded double quotes or single quotes.
-                    #   No problem: we enclose it in double quotes.
-                    # * Contains embedded single quotes. No problem:
-                    #   double quotes work here too.
-                    # * Contains embedded double quotes. No problem:
-                    #   we enclose it in single quotes.
-                    # * Embeds both single _and_ double quotes. This
-                    #   can't happen naturally, but it can happen if
-                    #   you modify an attribute value after parsing
-                    #   the document. Now we have a bit of a
-                    #   problem. We solve it by enclosing the
-                    #   attribute in single quotes, and escaping any
-                    #   embedded single quotes to XML entities.
-                    if '"' in val:
-                        fmt = "%s='%s'"
-                        if "'" in val:
-                            # TODO: replace with apos when
-                            # appropriate.
-                            val = val.replace("'", "&squot;")
-
-                    # Now we're okay w/r/t quotes. But the attribute
-                    # value might also contain angle brackets, or
-                    # ampersands that aren't part of entities. We need
-                    # to escape those to XML entities too.
-                    val = self.BARE_AMPERSAND_OR_BRACKET.sub(self._sub_entity, val)
-
-                attrs.append(fmt % (self.toEncoding(key, encoding),
-                                    self.toEncoding(val, encoding)))
-        close = ''
-        closeTag = ''
-        if self.isSelfClosing:
-            close = ' /'
-        else:
-            closeTag = '</%s>' % encodedName
-
-        indentTag, indentContents = 0, 0
-        if prettyPrint:
-            indentTag = indentLevel
-            space = (' ' * (indentTag-1))
-            indentContents = indentTag + 1
-        contents = self.renderContents(encoding, prettyPrint, indentContents)
-        if self.hidden:
-            s = contents
-        else:
-            s = []
-            attributeString = ''
-            if attrs:
-                attributeString = ' ' + ' '.join(attrs)
-            if prettyPrint:
-                s.append(space)
-            s.append('<%s%s%s>' % (encodedName, attributeString, close))
-            if prettyPrint:
-                s.append("\n")
-            s.append(contents)
-            if prettyPrint and contents and contents[-1] != "\n":
-                s.append("\n")
-            if prettyPrint and closeTag:
-                s.append(space)
-            s.append(closeTag)
-            if prettyPrint and closeTag and self.nextSibling:
-                s.append("\n")
-            s = ''.join(s)
-        return s
-
-    def decompose(self):
-        """Recursively destroys the contents of this tree."""
-        self.extract()
-        if len(self.contents) == 0:
-            return
-        current = self.contents[0]
-        while current is not None:
-            next = current.next
-            if isinstance(current, Tag):
-                del current.contents[:]
-            current.parent = None
-            current.previous = None
-            current.previousSibling = None
-            current.next = None
-            current.nextSibling = None
-            current = next
-
-    def prettify(self, encoding=DEFAULT_OUTPUT_ENCODING):
-        return self.__str__(encoding, True)
-
-    def renderContents(self, encoding=DEFAULT_OUTPUT_ENCODING,
-                       prettyPrint=False, indentLevel=0):
-        """Renders the contents of this tag as a string in the given
-        encoding. If encoding is None, returns a Unicode string.."""
-        s=[]
-        for c in self:
-            text = None
-            if isinstance(c, NavigableString):
-                text = c.__str__(encoding)
-            elif isinstance(c, Tag):
-                s.append(c.__str__(encoding, prettyPrint, indentLevel))
-            if text and prettyPrint:
-                text = text.strip()
-            if text:
-                if prettyPrint:
-                    s.append(" " * (indentLevel-1))
-                s.append(text)
-                if prettyPrint:
-                    s.append("\n")
-        return ''.join(s)
-
-    #Soup methods
-
-    def find(self, name=None, attrs={}, recursive=True, text=None,
-             **kwargs):
-        """Return only the first child of this Tag matching the given
-        criteria."""
-        r = None
-        l = self.findAll(name, attrs, recursive, text, 1, **kwargs)
-        if l:
-            r = l[0]
-        return r
-    findChild = find
-
-    def findAll(self, name=None, attrs={}, recursive=True, text=None,
-                limit=None, **kwargs):
-        """Extracts a list of Tag objects that match the given
-        criteria.  You can specify the name of the Tag and any
-        attributes you want the Tag to have.
-
-        The value of a key-value pair in the 'attrs' map can be a
-        string, a list of strings, a regular expression object, or a
-        callable that takes a string and returns whether or not the
-        string matches for some custom definition of 'matches'. The
-        same is true of the tag name."""
-        generator = self.recursiveChildGenerator
-        if not recursive:
-            generator = self.childGenerator
-        return self._findAll(name, attrs, text, limit, generator, **kwargs)
-    findChildren = findAll
-
-    # Pre-3.x compatibility methods
-    first = find
-    fetch = findAll
-
-    def fetchText(self, text=None, recursive=True, limit=None):
-        return self.findAll(text=text, recursive=recursive, limit=limit)
-
-    def firstText(self, text=None, recursive=True):
-        return self.find(text=text, recursive=recursive)
-
-    #Private methods
-
-    def _getAttrMap(self):
-        """Initializes a map representation of this tag's attributes,
-        if not already initialized."""
-        if not getattr(self, 'attrMap'):
-            self.attrMap = {}
-            for (key, value) in self.attrs:
-                self.attrMap[key] = value
-        return self.attrMap
-
-    #Generator methods
-    def childGenerator(self):
-        # Just use the iterator from the contents
-        return iter(self.contents)
-
-    def recursiveChildGenerator(self):
-        if not len(self.contents):
-            raise StopIteration
-        stopNode = self._lastRecursiveChild().next
-        current = self.contents[0]
-        while current is not stopNode:
-            yield current
-            current = current.next
-
-
-# Next, a couple classes to represent queries and their results.
-class SoupStrainer:
-    """Encapsulates a number of ways of matching a markup element (tag or
-    text)."""
-
-    def __init__(self, name=None, attrs={}, text=None, **kwargs):
-        self.name = name
-        if isinstance(attrs, basestring):
-            kwargs['class'] = _match_css_class(attrs)
-            attrs = None
-        if kwargs:
-            if attrs:
-                attrs = attrs.copy()
-                attrs.update(kwargs)
-            else:
-                attrs = kwargs
-        self.attrs = attrs
-        self.text = text
-
-    def __str__(self):
-        if self.text:
-            return self.text
-        else:
-            return "%s|%s" % (self.name, self.attrs)
-
-    def searchTag(self, markupName=None, markupAttrs={}):
-        found = None
-        markup = None
-        if isinstance(markupName, Tag):
-            markup = markupName
-            markupAttrs = markup
-        callFunctionWithTagData = callable(self.name) \
-                                and not isinstance(markupName, Tag)
-
-        if (not self.name) \
-               or callFunctionWithTagData \
-               or (markup and self._matches(markup, self.name)) \
-               or (not markup and self._matches(markupName, self.name)):
-            if callFunctionWithTagData:
-                match = self.name(markupName, markupAttrs)
-            else:
-                match = True
-                markupAttrMap = None
-                for attr, matchAgainst in self.attrs.items():
-                    if not markupAttrMap:
-                         if hasattr(markupAttrs, 'get'):
-                            markupAttrMap = markupAttrs
-                         else:
-                            markupAttrMap = {}
-                            for k,v in markupAttrs:
-                                markupAttrMap[k] = v
-                    attrValue = markupAttrMap.get(attr)
-                    if not self._matches(attrValue, matchAgainst):
-                        match = False
-                        break
-            if match:
-                if markup:
-                    found = markup
-                else:
-                    found = markupName
-        return found
-
-    def search(self, markup):
-        #print 'looking for %s in %s' % (self, markup)
-        found = None
-        # If given a list of items, scan it for a text element that
-        # matches.
-        if hasattr(markup, "__iter__") \
-                and not isinstance(markup, Tag):
-            for element in markup:
-                if isinstance(element, NavigableString) \
-                       and self.search(element):
-                    found = element
-                    break
-        # If it's a Tag, make sure its name or attributes match.
-        # Don't bother with Tags if we're searching for text.
-        elif isinstance(markup, Tag):
-            if not self.text:
-                found = self.searchTag(markup)
-        # If it's text, make sure the text matches.
-        elif isinstance(markup, NavigableString) or \
-                 isinstance(markup, basestring):
-            if self._matches(markup, self.text):
-                found = markup
-        else:
-            raise Exception, "I don't know how to match against a %s" \
-                  % markup.__class__
-        return found
-
-    def _matches(self, markup, matchAgainst):
-        #print "Matching %s against %s" % (markup, matchAgainst)
-        result = False
-        if matchAgainst is True:
-            result = markup is not None
-        elif callable(matchAgainst):
-            result = matchAgainst(markup)
-        else:
-            #Custom match methods take the tag as an argument, but all
-            #other ways of matching match the tag name as a string.
-            if isinstance(markup, Tag):
-                markup = markup.name
-            if markup and not isinstance(markup, basestring):
-                markup = unicode(markup)
-            #Now we know that chunk is either a string, or None.
-            if hasattr(matchAgainst, 'match'):
-                # It's a regexp object.
-                result = markup and matchAgainst.search(markup)
-            elif hasattr(matchAgainst, '__iter__'): # list-like
-                result = markup in matchAgainst
-            elif hasattr(matchAgainst, 'items'):
-                result = markup.has_key(matchAgainst)
-            elif matchAgainst and isinstance(markup, basestring):
-                if isinstance(markup, unicode):
-                    matchAgainst = unicode(matchAgainst)
-                else:
-                    matchAgainst = str(matchAgainst)
-
-            if not result:
-                result = matchAgainst == markup
-        return result
-
-class ResultSet(list):
-    """A ResultSet is just a list that keeps track of the SoupStrainer
-    that created it."""
-    def __init__(self, source):
-        list.__init__([])
-        self.source = source
-
-# Now, some helper functions.
-
-def buildTagMap(default, *args):
-    """Turns a list of maps, lists, or scalars into a single map.
-    Used to build the SELF_CLOSING_TAGS, NESTABLE_TAGS, and
-    NESTING_RESET_TAGS maps out of lists and partial maps."""
-    built = {}
-    for portion in args:
-        if hasattr(portion, 'items'):
-            #It's a map. Merge it.
-            for k,v in portion.items():
-                built[k] = v
-        elif hasattr(portion, '__iter__'): # is a list
-            #It's a list. Map each item to the default.
-            for k in portion:
-                built[k] = default
-        else:
-            #It's a scalar. Map it to the default.
-            built[portion] = default
-    return built
-
-# Now, the parser classes.
-
-class BeautifulStoneSoup(Tag, SGMLParser):
-
-    """This class contains the basic parser and search code. It defines
-    a parser that knows nothing about tag behavior except for the
-    following:
-
-      You can't close a tag without closing all the tags it encloses.
-      That is, "<foo><bar></foo>" actually means
-      "<foo><bar></bar></foo>".
-
-    [Another possible explanation is "<foo><bar /></foo>", but since
-    this class defines no SELF_CLOSING_TAGS, it will never use that
-    explanation.]
-
-    This class is useful for parsing XML or made-up markup languages,
-    or when BeautifulSoup makes an assumption counter to what you were
-    expecting."""
-
-    SELF_CLOSING_TAGS = {}
-    NESTABLE_TAGS = {}
-    RESET_NESTING_TAGS = {}
-    QUOTE_TAGS = {}
-    PRESERVE_WHITESPACE_TAGS = []
-
-    MARKUP_MASSAGE = [(re.compile('(<[^<>]*)/>'),
-                       lambda x: x.group(1) + ' />'),
-                      (re.compile('<!\s+([^<>]*)>'),
-                       lambda x: '<!' + x.group(1) + '>')
-                      ]
-
-    ROOT_TAG_NAME = u'[document]'
-
-    HTML_ENTITIES = "html"
-    XML_ENTITIES = "xml"
-    XHTML_ENTITIES = "xhtml"
-    # TODO: This only exists for backwards-compatibility
-    ALL_ENTITIES = XHTML_ENTITIES
-
-    # Used when determining whether a text node is all whitespace and
-    # can be replaced with a single space. A text node that contains
-    # fancy Unicode spaces (usually non-breaking) should be left
-    # alone.
-    STRIP_ASCII_SPACES = { 9: None, 10: None, 12: None, 13: None, 32: None, }
-
-    def __init__(self, markup="", parseOnlyThese=None, fromEncoding=None,
-                 markupMassage=True, smartQuotesTo=XML_ENTITIES,
-                 convertEntities=None, selfClosingTags=None, isHTML=False):
-        """The Soup object is initialized as the 'root tag', and the
-        provided markup (which can be a string or a file-like object)
-        is fed into the underlying parser.
-
-        sgmllib will process most bad HTML, and the BeautifulSoup
-        class has some tricks for dealing with some HTML that kills
-        sgmllib, but Beautiful Soup can nonetheless choke or lose data
-        if your data uses self-closing tags or declarations
-        incorrectly.
-
-        By default, Beautiful Soup uses regexes to sanitize input,
-        avoiding the vast majority of these problems. If the problems
-        don't apply to you, pass in False for markupMassage, and
-        you'll get better performance.
-
-        The default parser massage techniques fix the two most common
-        instances of invalid HTML that choke sgmllib:
-
-         <br/> (No space between name of closing tag and tag close)
-         <! --Comment--> (Extraneous whitespace in declaration)
-
-        You can pass in a custom list of (RE object, replace method)
-        tuples to get Beautiful Soup to scrub your input the way you
-        want."""
-
-        self.parseOnlyThese = parseOnlyThese
-        self.fromEncoding = fromEncoding
-        self.smartQuotesTo = smartQuotesTo
-        self.convertEntities = convertEntities
-        # Set the rules for how we'll deal with the entities we
-        # encounter
-        if self.convertEntities:
-            # It doesn't make sense to convert encoded characters to
-            # entities even while you're converting entities to Unicode.
-            # Just convert it all to Unicode.
-            self.smartQuotesTo = None
-            if convertEntities == self.HTML_ENTITIES:
-                self.convertXMLEntities = False
-                self.convertHTMLEntities = True
-                self.escapeUnrecognizedEntities = True
-            elif convertEntities == self.XHTML_ENTITIES:
-                self.convertXMLEntities = True
-                self.convertHTMLEntities = True
-                self.escapeUnrecognizedEntities = False
-            elif convertEntities == self.XML_ENTITIES:
-                self.convertXMLEntities = True
-                self.convertHTMLEntities = False
-                self.escapeUnrecognizedEntities = False
-        else:
-            self.convertXMLEntities = False
-            self.convertHTMLEntities = False
-            self.escapeUnrecognizedEntities = False
-
-        self.instanceSelfClosingTags = buildTagMap(None, selfClosingTags)
-        SGMLParser.__init__(self)
-
-        if hasattr(markup, 'read'):        # It's a file-type object.
-            markup = markup.read()
-        self.markup = markup
-        self.markupMassage = markupMassage
-        try:
-            self._feed(isHTML=isHTML)
-        except StopParsing:
-            pass
-        self.markup = None                 # The markup can now be GCed
-
-    def convert_charref(self, name):
-        """This method fixes a bug in Python's SGMLParser."""
-        try:
-            n = int(name)
-        except ValueError:
-            return
-        if not 0 <= n <= 127 : # ASCII ends at 127, not 255
-            return
-        return self.convert_codepoint(n)
-
-    def _feed(self, inDocumentEncoding=None, isHTML=False):
-        # Convert the document to Unicode.
-        markup = self.markup
-        if isinstance(markup, unicode):
-            if not hasattr(self, 'originalEncoding'):
-                self.originalEncoding = None
-        else:
-            dammit = UnicodeDammit\
-                     (markup, [self.fromEncoding, inDocumentEncoding],
-                      smartQuotesTo=self.smartQuotesTo, isHTML=isHTML)
-            markup = dammit.unicode
-            self.originalEncoding = dammit.originalEncoding
-            self.declaredHTMLEncoding = dammit.declaredHTMLEncoding
-        if markup:
-            if self.markupMassage:
-                if not hasattr(self.markupMassage, "__iter__"):
-                    self.markupMassage = self.MARKUP_MASSAGE
-                for fix, m in self.markupMassage:
-                    markup = fix.sub(m, markup)
-                # TODO: We get rid of markupMassage so that the
-                # soup object can be deepcopied later on. Some
-                # Python installations can't copy regexes. If anyone
-                # was relying on the existence of markupMassage, this
-                # might cause problems.
-                del(self.markupMassage)
-        self.reset()
-
-        SGMLParser.feed(self, markup)
-        # Close out any unfinished strings and close all the open tags.
-        self.endData()
-        while self.currentTag.name != self.ROOT_TAG_NAME:
-            self.popTag()
-
-    def __getattr__(self, methodName):
-        """This method routes method call requests to either the SGMLParser
-        superclass or the Tag superclass, depending on the method name."""
-        #print "__getattr__ called on %s.%s" % (self.__class__, methodName)
-
-        if methodName.startswith('start_') or methodName.startswith('end_') \
-               or methodName.startswith('do_'):
-            return SGMLParser.__getattr__(self, methodName)
-        elif not methodName.startswith('__'):
-            return Tag.__getattr__(self, methodName)
-        else:
-            raise AttributeError
-
-    def isSelfClosingTag(self, name):
-        """Returns true iff the given string is the name of a
-        self-closing tag according to this parser."""
-        return self.SELF_CLOSING_TAGS.has_key(name) \
-               or self.instanceSelfClosingTags.has_key(name)
-
-    def reset(self):
-        Tag.__init__(self, self, self.ROOT_TAG_NAME)
-        self.hidden = 1
-        SGMLParser.reset(self)
-        self.currentData = []
-        self.currentTag = None
-        self.tagStack = []
-        self.quoteStack = []
-        self.pushTag(self)
-
-    def popTag(self):
-        tag = self.tagStack.pop()
-
-        #print "Pop", tag.name
-        if self.tagStack:
-            self.currentTag = self.tagStack[-1]
-        return self.currentTag
-
-    def pushTag(self, tag):
-        #print "Push", tag.name
-        if self.currentTag:
-            self.currentTag.contents.append(tag)
-        self.tagStack.append(tag)
-        self.currentTag = self.tagStack[-1]
-
-    def endData(self, containerClass=NavigableString):
-        if self.currentData:
-            currentData = u''.join(self.currentData)
-            if (currentData.translate(self.STRIP_ASCII_SPACES) == '' and
-                not set([tag.name for tag in self.tagStack]).intersection(
-                    self.PRESERVE_WHITESPACE_TAGS)):
-                if '\n' in currentData:
-                    currentData = '\n'
-                else:
-                    currentData = ' '
-            self.currentData = []
-            if self.parseOnlyThese and len(self.tagStack) <= 1 and \
-                   (not self.parseOnlyThese.text or \
-                    not self.parseOnlyThese.search(currentData)):
-                return
-            o = containerClass(currentData)
-            o.setup(self.currentTag, self.previous)
-            if self.previous:
-                self.previous.next = o
-            self.previous = o
-            self.currentTag.contents.append(o)
-
-
-    def _popToTag(self, name, inclusivePop=True):
-        """Pops the tag stack up to and including the most recent
-        instance of the given tag. If inclusivePop is false, pops the tag
-        stack up to but *not* including the most recent instqance of
-        the given tag."""
-        #print "Popping to %s" % name
-        if name == self.ROOT_TAG_NAME:
-            return
-
-        numPops = 0
-        mostRecentTag = None
-        for i in range(len(self.tagStack)-1, 0, -1):
-            if name == self.tagStack[i].name:
-                numPops = len(self.tagStack)-i
-                break
-        if not inclusivePop:
-            numPops = numPops - 1
-
-        for i in range(0, numPops):
-            mostRecentTag = self.popTag()
-        return mostRecentTag
-
-    def _smartPop(self, name):
-
-        """We need to pop up to the previous tag of this type, unless
-        one of this tag's nesting reset triggers comes between this
-        tag and the previous tag of this type, OR unless this tag is a
-        generic nesting trigger and another generic nesting trigger
-        comes between this tag and the previous tag of this type.
-
-        Examples:
-         <p>Foo<b>Bar *<p>* should pop to 'p', not 'b'.
-         <p>Foo<table>Bar *<p>* should pop to 'table', not 'p'.
-         <p>Foo<table><tr>Bar *<p>* should pop to 'tr', not 'p'.
-
-         <li><ul><li> *<li>* should pop to 'ul', not the first 'li'.
-         <tr><table><tr> *<tr>* should pop to 'table', not the first 'tr'
-         <td><tr><td> *<td>* should pop to 'tr', not the first 'td'
-        """
-
-        nestingResetTriggers = self.NESTABLE_TAGS.get(name)
-        isNestable = nestingResetTriggers is not None
-        isResetNesting = self.RESET_NESTING_TAGS.has_key(name)
-        popTo = None
-        inclusive = True
-        for i in range(len(self.tagStack)-1, 0, -1):
-            p = self.tagStack[i]
-            if (not p or p.name == name) and not isNestable:
-                #Non-nestable tags get popped to the top or to their
-                #last occurance.
-                popTo = name
-                break
-            if (nestingResetTriggers is not None
-                and p.name in nestingResetTriggers) \
-                or (nestingResetTriggers is None and isResetNesting
-                    and self.RESET_NESTING_TAGS.has_key(p.name)):
-
-                #If we encounter one of the nesting reset triggers
-                #peculiar to this tag, or we encounter another tag
-                #that causes nesting to reset, pop up to but not
-                #including that tag.
-                popTo = p.name
-                inclusive = False
-                break
-            p = p.parent
-        if popTo:
-            self._popToTag(popTo, inclusive)
-
-    def unknown_starttag(self, name, attrs, selfClosing=0):
-        #print "Start tag %s: %s" % (name, attrs)
-        if self.quoteStack:
-            #This is not a real tag.
-            #print "<%s> is not real!" % name
-            attrs = ''.join([' %s="%s"' % (x, y) for x, y in attrs])
-            self.handle_data('<%s%s>' % (name, attrs))
-            return
-        self.endData()
-
-        if not self.isSelfClosingTag(name) and not selfClosing:
-            self._smartPop(name)
-
-        if self.parseOnlyThese and len(self.tagStack) <= 1 \
-               and (self.parseOnlyThese.text or not self.parseOnlyThese.searchTag(name, attrs)):
-            return
-
-        tag = Tag(self, name, attrs, self.currentTag, self.previous)
-        if self.previous:
-            self.previous.next = tag
-        self.previous = tag
-        self.pushTag(tag)
-        if selfClosing or self.isSelfClosingTag(name):
-            self.popTag()
-        if name in self.QUOTE_TAGS:
-            #print "Beginning quote (%s)" % name
-            self.quoteStack.append(name)
-            self.literal = 1
-        return tag
-
-    def unknown_endtag(self, name):
-        #print "End tag %s" % name
-        if self.quoteStack and self.quoteStack[-1] != name:
-            #This is not a real end tag.
-            #print "</%s> is not real!" % name
-            self.handle_data('</%s>' % name)
-            return
-        self.endData()
-        self._popToTag(name)
-        if self.quoteStack and self.quoteStack[-1] == name:
-            self.quoteStack.pop()
-            self.literal = (len(self.quoteStack) > 0)
-
-    def handle_data(self, data):
-        self.currentData.append(data)
-
-    def _toStringSubclass(self, text, subclass):
-        """Adds a certain piece of text to the tree as a NavigableString
-        subclass."""
-        self.endData()
-        self.handle_data(text)
-        self.endData(subclass)
-
-    def handle_pi(self, text):
-        """Handle a processing instruction as a ProcessingInstruction
-        object, possibly one with a %SOUP-ENCODING% slot into which an
-        encoding will be plugged later."""
-        if text[:3] == "xml":
-            text = u"xml version='1.0' encoding='%SOUP-ENCODING%'"
-        self._toStringSubclass(text, ProcessingInstruction)
-
-    def handle_comment(self, text):
-        "Handle comments as Comment objects."
-        self._toStringSubclass(text, Comment)
-
-    def handle_charref(self, ref):
-        "Handle character references as data."
-        if self.convertEntities:
-            data = unichr(int(ref))
-        else:
-            data = '&#%s;' % ref
-        self.handle_data(data)
-
-    def handle_entityref(self, ref):
-        """Handle entity references as data, possibly converting known
-        HTML and/or XML entity references to the corresponding Unicode
-        characters."""
-        data = None
-        if self.convertHTMLEntities:
-            try:
-                data = unichr(name2codepoint[ref])
-            except KeyError:
-                pass
-
-        if not data and self.convertXMLEntities:
-                data = self.XML_ENTITIES_TO_SPECIAL_CHARS.get(ref)
-
-        if not data and self.convertHTMLEntities and \
-            not self.XML_ENTITIES_TO_SPECIAL_CHARS.get(ref):
-                # TODO: We've got a problem here. We're told this is
-                # an entity reference, but it's not an XML entity
-                # reference or an HTML entity reference. Nonetheless,
-                # the logical thing to do is to pass it through as an
-                # unrecognized entity reference.
-                #
-                # Except: when the input is "&carol;" this function
-                # will be called with input "carol". When the input is
-                # "AT&T", this function will be called with input
-                # "T". We have no way of knowing whether a semicolon
-                # was present originally, so we don't know whether
-                # this is an unknown entity or just a misplaced
-                # ampersand.
-                #
-                # The more common case is a misplaced ampersand, so I
-                # escape the ampersand and omit the trailing semicolon.
-                data = "&amp;%s" % ref
-        if not data:
-            # This case is different from the one above, because we
-            # haven't already gone through a supposedly comprehensive
-            # mapping of entities to Unicode characters. We might not
-            # have gone through any mapping at all. So the chances are
-            # very high that this is a real entity, and not a
-            # misplaced ampersand.
-            data = "&%s;" % ref
-        self.handle_data(data)
-
-    def handle_decl(self, data):
-        "Handle DOCTYPEs and the like as Declaration objects."
-        self._toStringSubclass(data, Declaration)
-
-    def parse_declaration(self, i):
-        """Treat a bogus SGML declaration as raw data. Treat a CDATA
-        declaration as a CData object."""
-        j = None
-        if self.rawdata[i:i+9] == '<![CDATA[':
-             k = self.rawdata.find(']]>', i)
-             if k == -1:
-                 k = len(self.rawdata)
-             data = self.rawdata[i+9:k]
-             j = k+3
-             self._toStringSubclass(data, CData)
-        else:
-            try:
-                j = SGMLParser.parse_declaration(self, i)
-            except SGMLParseError:
-                toHandle = self.rawdata[i:]
-                self.handle_data(toHandle)
-                j = i + len(toHandle)
-        return j
-
-class BeautifulSoup(BeautifulStoneSoup):
-
-    """This parser knows the following facts about HTML:
-
-    * Some tags have no closing tag and should be interpreted as being
-      closed as soon as they are encountered.
-
-    * The text inside some tags (ie. 'script') may contain tags which
-      are not really part of the document and which should be parsed
-      as text, not tags. If you want to parse the text as tags, you can
-      always fetch it and parse it explicitly.
-
-    * Tag nesting rules:
-
-      Most tags can't be nested at all. For instance, the occurance of
-      a <p> tag should implicitly close the previous <p> tag.
-
-       <p>Para1<p>Para2
-        should be transformed into:
-       <p>Para1</p><p>Para2
-
-      Some tags can be nested arbitrarily. For instance, the occurance
-      of a <blockquote> tag should _not_ implicitly close the previous
-      <blockquote> tag.
-
-       Alice said: <blockquote>Bob said: <blockquote>Blah
-        should NOT be transformed into:
-       Alice said: <blockquote>Bob said: </blockquote><blockquote>Blah
-
-      Some tags can be nested, but the nesting is reset by the
-      interposition of other tags. For instance, a <tr> tag should
-      implicitly close the previous <tr> tag within the same <table>,
-      but not close a <tr> tag in another table.
-
-       <table><tr>Blah<tr>Blah
-        should be transformed into:
-       <table><tr>Blah</tr><tr>Blah
-        but,
-       <tr>Blah<table><tr>Blah
-        should NOT be transformed into
-       <tr>Blah<table></tr><tr>Blah
-
-    Differing assumptions about tag nesting rules are a major source
-    of problems with the BeautifulSoup class. If BeautifulSoup is not
-    treating as nestable a tag your page author treats as nestable,
-    try ICantBelieveItsBeautifulSoup, MinimalSoup, or
-    BeautifulStoneSoup before writing your own subclass."""
-
-    def __init__(self, *args, **kwargs):
-        if not kwargs.has_key('smartQuotesTo'):
-            kwargs['smartQuotesTo'] = self.HTML_ENTITIES
-        kwargs['isHTML'] = True
-        BeautifulStoneSoup.__init__(self, *args, **kwargs)
-
-    SELF_CLOSING_TAGS = buildTagMap(None,
-                                    ('br' , 'hr', 'input', 'img', 'meta',
-                                    'spacer', 'link', 'frame', 'base', 'col'))
-
-    PRESERVE_WHITESPACE_TAGS = set(['pre', 'textarea'])
-
-    QUOTE_TAGS = {'script' : None, 'textarea' : None}
-
-    #According to the HTML standard, each of these inline tags can
-    #contain another tag of the same type. Furthermore, it's common
-    #to actually use these tags this way.
-    NESTABLE_INLINE_TAGS = ('span', 'font', 'q', 'object', 'bdo', 'sub', 'sup',
-                            'center')
-
-    #According to the HTML standard, these block tags can contain
-    #another tag of the same type. Furthermore, it's common
-    #to actually use these tags this way.
-    NESTABLE_BLOCK_TAGS = ('blockquote', 'div', 'fieldset', 'ins', 'del')
-
-    #Lists can contain other lists, but there are restrictions.
-    NESTABLE_LIST_TAGS = { 'ol' : [],
-                           'ul' : [],
-                           'li' : ['ul', 'ol'],
-                           'dl' : [],
-                           'dd' : ['dl'],
-                           'dt' : ['dl'] }
-
-    #Tables can contain other tables, but there are restrictions.
-    NESTABLE_TABLE_TAGS = {'table' : [],
-                           'tr' : ['table', 'tbody', 'tfoot', 'thead'],
-                           'td' : ['tr'],
-                           'th' : ['tr'],
-                           'thead' : ['table'],
-                           'tbody' : ['table'],
-                           'tfoot' : ['table'],
-                           }
-
-    NON_NESTABLE_BLOCK_TAGS = ('address', 'form', 'p', 'pre')
-
-    #If one of these tags is encountered, all tags up to the next tag of
-    #this type are popped.
-    RESET_NESTING_TAGS = buildTagMap(None, NESTABLE_BLOCK_TAGS, 'noscript',
-                                     NON_NESTABLE_BLOCK_TAGS,
-                                     NESTABLE_LIST_TAGS,
-                                     NESTABLE_TABLE_TAGS)
-
-    NESTABLE_TAGS = buildTagMap([], NESTABLE_INLINE_TAGS, NESTABLE_BLOCK_TAGS,
-                                NESTABLE_LIST_TAGS, NESTABLE_TABLE_TAGS)
-
-    # Used to detect the charset in a META tag; see start_meta
-    CHARSET_RE = re.compile("((^|;)\s*charset=)([^;]*)", re.M)
-
-    def start_meta(self, attrs):
-        """Beautiful Soup can detect a charset included in a META tag,
-        try to convert the document to that charset, and re-parse the
-        document from the beginning."""
-        httpEquiv = None
-        contentType = None
-        contentTypeIndex = None
-        tagNeedsEncodingSubstitution = False
-
-        for i in range(0, len(attrs)):
-            key, value = attrs[i]
-            key = key.lower()
-            if key == 'http-equiv':
-                httpEquiv = value
-            elif key == 'content':
-                contentType = value
-                contentTypeIndex = i
-
-        if httpEquiv and contentType: # It's an interesting meta tag.
-            match = self.CHARSET_RE.search(contentType)
-            if match:
-                if (self.declaredHTMLEncoding is not None or
-                    self.originalEncoding == self.fromEncoding):
-                    # An HTML encoding was sniffed while converting
-                    # the document to Unicode, or an HTML encoding was
-                    # sniffed during a previous pass through the
-                    # document, or an encoding was specified
-                    # explicitly and it worked. Rewrite the meta tag.
-                    def rewrite(match):
-                        return match.group(1) + "%SOUP-ENCODING%"
-                    newAttr = self.CHARSET_RE.sub(rewrite, contentType)
-                    attrs[contentTypeIndex] = (attrs[contentTypeIndex][0],
-                                               newAttr)
-                    tagNeedsEncodingSubstitution = True
-                else:
-                    # This is our first pass through the document.
-                    # Go through it again with the encoding information.
-                    newCharset = match.group(3)
-                    if newCharset and newCharset != self.originalEncoding:
-                        self.declaredHTMLEncoding = newCharset
-                        self._feed(self.declaredHTMLEncoding)
-                        raise StopParsing
-                    pass
-        tag = self.unknown_starttag("meta", attrs)
-        if tag and tagNeedsEncodingSubstitution:
-            tag.containsSubstitutions = True
-
-class StopParsing(Exception):
-    pass
-
-class ICantBelieveItsBeautifulSoup(BeautifulSoup):
-
-    """The BeautifulSoup class is oriented towards skipping over
-    common HTML errors like unclosed tags. However, sometimes it makes
-    errors of its own. For instance, consider this fragment:
-
-     <b>Foo<b>Bar</b></b>
-
-    This is perfectly valid (if bizarre) HTML. However, the
-    BeautifulSoup class will implicitly close the first b tag when it
-    encounters the second 'b'. It will think the author wrote
-    "<b>Foo<b>Bar", and didn't close the first 'b' tag, because
-    there's no real-world reason to bold something that's already
-    bold. When it encounters '</b></b>' it will close two more 'b'
-    tags, for a grand total of three tags closed instead of two. This
-    can throw off the rest of your document structure. The same is
-    true of a number of other tags, listed below.
-
-    It's much more common for someone to forget to close a 'b' tag
-    than to actually use nested 'b' tags, and the BeautifulSoup class
-    handles the common case. This class handles the not-co-common
-    case: where you can't believe someone wrote what they did, but
-    it's valid HTML and BeautifulSoup screwed up by assuming it
-    wouldn't be."""
-
-    I_CANT_BELIEVE_THEYRE_NESTABLE_INLINE_TAGS = \
-     ('em', 'big', 'i', 'small', 'tt', 'abbr', 'acronym', 'strong',
-      'cite', 'code', 'dfn', 'kbd', 'samp', 'strong', 'var', 'b',
-      'big')
-
-    I_CANT_BELIEVE_THEYRE_NESTABLE_BLOCK_TAGS = ('noscript',)
-
-    NESTABLE_TAGS = buildTagMap([], BeautifulSoup.NESTABLE_TAGS,
-                                I_CANT_BELIEVE_THEYRE_NESTABLE_BLOCK_TAGS,
-                                I_CANT_BELIEVE_THEYRE_NESTABLE_INLINE_TAGS)
-
-class MinimalSoup(BeautifulSoup):
-    """The MinimalSoup class is for parsing HTML that contains
-    pathologically bad markup. It makes no assumptions about tag
-    nesting, but it does know which tags are self-closing, that
-    <script> tags contain Javascript and should not be parsed, that
-    META tags may contain encoding information, and so on.
-
-    This also makes it better for subclassing than BeautifulStoneSoup
-    or BeautifulSoup."""
-
-    RESET_NESTING_TAGS = buildTagMap('noscript')
-    NESTABLE_TAGS = {}
-
-class BeautifulSOAP(BeautifulStoneSoup):
-    """This class will push a tag with only a single string child into
-    the tag's parent as an attribute. The attribute's name is the tag
-    name, and the value is the string child. An example should give
-    the flavor of the change:
-
-    <foo><bar>baz</bar></foo>
-     =>
-    <foo bar="baz"><bar>baz</bar></foo>
-
-    You can then access fooTag['bar'] instead of fooTag.barTag.string.
-
-    This is, of course, useful for scraping structures that tend to
-    use subelements instead of attributes, such as SOAP messages. Note
-    that it modifies its input, so don't print the modified version
-    out.
-
-    I'm not sure how many people really want to use this class; let me
-    know if you do. Mainly I like the name."""
-
-    def popTag(self):
-        if len(self.tagStack) > 1:
-            tag = self.tagStack[-1]
-            parent = self.tagStack[-2]
-            parent._getAttrMap()
-            if (isinstance(tag, Tag) and len(tag.contents) == 1 and
-                isinstance(tag.contents[0], NavigableString) and
-                not parent.attrMap.has_key(tag.name)):
-                parent[tag.name] = tag.contents[0]
-        BeautifulStoneSoup.popTag(self)
-
-#Enterprise class names! It has come to our attention that some people
-#think the names of the Beautiful Soup parser classes are too silly
-#and "unprofessional" for use in enterprise screen-scraping. We feel
-#your pain! For such-minded folk, the Beautiful Soup Consortium And
-#All-Night Kosher Bakery recommends renaming this file to
-#"RobustParser.py" (or, in cases of extreme enterprisiness,
-#"RobustParserBeanInterface.class") and using the following
-#enterprise-friendly class aliases:
-class RobustXMLParser(BeautifulStoneSoup):
-    pass
-class RobustHTMLParser(BeautifulSoup):
-    pass
-class RobustWackAssHTMLParser(ICantBelieveItsBeautifulSoup):
-    pass
-class RobustInsanelyWackAssHTMLParser(MinimalSoup):
-    pass
-class SimplifyingSOAPParser(BeautifulSOAP):
-    pass
-
-######################################################
-#
-# Bonus library: Unicode, Dammit
-#
-# This class forces XML data into a standard format (usually to UTF-8
-# or Unicode).  It is heavily based on code from Mark Pilgrim's
-# Universal Feed Parser. It does not rewrite the XML or HTML to
-# reflect a new encoding: that happens in BeautifulStoneSoup.handle_pi
-# (XML) and BeautifulSoup.start_meta (HTML).
-
-# Autodetects character encodings.
-# Download from http://chardet.feedparser.org/
-try:
-    import chardet
-#    import chardet.constants
-#    chardet.constants._debug = 1
-except ImportError:
-    chardet = None
-
-# cjkcodecs and iconv_codec make Python know about more character encodings.
-# Both are available from http://cjkpython.i18n.org/
-# They're built in if you use Python 2.4.
-try:
-    import cjkcodecs.aliases
-except ImportError:
-    pass
-try:
-    import iconv_codec
-except ImportError:
-    pass
-
-class UnicodeDammit:
-    """A class for detecting the encoding of a *ML document and
-    converting it to a Unicode string. If the source encoding is
-    windows-1252, can replace MS smart quotes with their HTML or XML
-    equivalents."""
-
-    # This dictionary maps commonly seen values for "charset" in HTML
-    # meta tags to the corresponding Python codec names. It only covers
-    # values that aren't in Python's aliases and can't be determined
-    # by the heuristics in find_codec.
-    CHARSET_ALIASES = { "macintosh" : "mac-roman",
-                        "x-sjis" : "shift-jis" }
-
-    def __init__(self, markup, overrideEncodings=[],
-                 smartQuotesTo='xml', isHTML=False):
-        self.declaredHTMLEncoding = None
-        self.markup, documentEncoding, sniffedEncoding = \
-                     self._detectEncoding(markup, isHTML)
-        self.smartQuotesTo = smartQuotesTo
-        self.triedEncodings = []
-        if markup == '' or isinstance(markup, unicode):
-            self.originalEncoding = None
-            self.unicode = unicode(markup)
-            return
-
-        u = None
-        for proposedEncoding in overrideEncodings:
-            u = self._convertFrom(proposedEncoding)
-            if u: break
-        if not u:
-            for proposedEncoding in (documentEncoding, sniffedEncoding):
-                u = self._convertFrom(proposedEncoding)
-                if u: break
-
-        # If no luck and we have auto-detection library, try that:
-        if not u and chardet and not isinstance(self.markup, unicode):
-            u = self._convertFrom(chardet.detect(self.markup)['encoding'])
-
-        # As a last resort, try utf-8 and windows-1252:
-        if not u:
-            for proposed_encoding in ("utf-8", "windows-1252"):
-                u = self._convertFrom(proposed_encoding)
-                if u: break
-
-        self.unicode = u
-        if not u: self.originalEncoding = None
-
-    def _subMSChar(self, orig):
-        """Changes a MS smart quote character to an XML or HTML
-        entity."""
-        sub = self.MS_CHARS.get(orig)
-        if isinstance(sub, tuple):
-            if self.smartQuotesTo == 'xml':
-                sub = '&#x%s;' % sub[1]
-            else:
-                sub = '&%s;' % sub[0]
-        return sub
-
-    def _convertFrom(self, proposed):
-        proposed = self.find_codec(proposed)
-        if not proposed or proposed in self.triedEncodings:
-            return None
-        self.triedEncodings.append(proposed)
-        markup = self.markup
-
-        # Convert smart quotes to HTML if coming from an encoding
-        # that might have them.
-        if self.smartQuotesTo and proposed.lower() in("windows-1252",
-                                                      "iso-8859-1",
-                                                      "iso-8859-2"):
-            markup = re.compile("([\x80-\x9f])").sub \
-                     (lambda(x): self._subMSChar(x.group(1)),
-                      markup)
-
-        try:
-            # print "Trying to convert document to %s" % proposed
-            u = self._toUnicode(markup, proposed)
-            self.markup = u
-            self.originalEncoding = proposed
-        except Exception, e:
-            # print "That didn't work!"
-            # print e
-            return None
-        #print "Correct encoding: %s" % proposed
-        return self.markup
-
-    def _toUnicode(self, data, encoding):
-        '''Given a string and its encoding, decodes the string into Unicode.
-        %encoding is a string recognized by encodings.aliases'''
-
-        # strip Byte Order Mark (if present)
-        if (len(data) >= 4) and (data[:2] == '\xfe\xff') \
-               and (data[2:4] != '\x00\x00'):
-            encoding = 'utf-16be'
-            data = data[2:]
-        elif (len(data) >= 4) and (data[:2] == '\xff\xfe') \
-                 and (data[2:4] != '\x00\x00'):
-            encoding = 'utf-16le'
-            data = data[2:]
-        elif data[:3] == '\xef\xbb\xbf':
-            encoding = 'utf-8'
-            data = data[3:]
-        elif data[:4] == '\x00\x00\xfe\xff':
-            encoding = 'utf-32be'
-            data = data[4:]
-        elif data[:4] == '\xff\xfe\x00\x00':
-            encoding = 'utf-32le'
-            data = data[4:]
-        newdata = unicode(data, encoding)
-        return newdata
-
-    def _detectEncoding(self, xml_data, isHTML=False):
-        """Given a document, tries to detect its XML encoding."""
-        xml_encoding = sniffed_xml_encoding = None
-        try:
-            if xml_data[:4] == '\x4c\x6f\xa7\x94':
-                # EBCDIC
-                xml_data = self._ebcdic_to_ascii(xml_data)
-            elif xml_data[:4] == '\x00\x3c\x00\x3f':
-                # UTF-16BE
-                sniffed_xml_encoding = 'utf-16be'
-                xml_data = unicode(xml_data, 'utf-16be').encode('utf-8')
-            elif (len(xml_data) >= 4) and (xml_data[:2] == '\xfe\xff') \
-                     and (xml_data[2:4] != '\x00\x00'):
-                # UTF-16BE with BOM
-                sniffed_xml_encoding = 'utf-16be'
-                xml_data = unicode(xml_data[2:], 'utf-16be').encode('utf-8')
-            elif xml_data[:4] == '\x3c\x00\x3f\x00':
-                # UTF-16LE
-                sniffed_xml_encoding = 'utf-16le'
-                xml_data = unicode(xml_data, 'utf-16le').encode('utf-8')
-            elif (len(xml_data) >= 4) and (xml_data[:2] == '\xff\xfe') and \
-                     (xml_data[2:4] != '\x00\x00'):
-                # UTF-16LE with BOM
-                sniffed_xml_encoding = 'utf-16le'
-                xml_data = unicode(xml_data[2:], 'utf-16le').encode('utf-8')
-            elif xml_data[:4] == '\x00\x00\x00\x3c':
-                # UTF-32BE
-                sniffed_xml_encoding = 'utf-32be'
-                xml_data = unicode(xml_data, 'utf-32be').encode('utf-8')
-            elif xml_data[:4] == '\x3c\x00\x00\x00':
-                # UTF-32LE
-                sniffed_xml_encoding = 'utf-32le'
-                xml_data = unicode(xml_data, 'utf-32le').encode('utf-8')
-            elif xml_data[:4] == '\x00\x00\xfe\xff':
-                # UTF-32BE with BOM
-                sniffed_xml_encoding = 'utf-32be'
-                xml_data = unicode(xml_data[4:], 'utf-32be').encode('utf-8')
-            elif xml_data[:4] == '\xff\xfe\x00\x00':
-                # UTF-32LE with BOM
-                sniffed_xml_encoding = 'utf-32le'
-                xml_data = unicode(xml_data[4:], 'utf-32le').encode('utf-8')
-            elif xml_data[:3] == '\xef\xbb\xbf':
-                # UTF-8 with BOM
-                sniffed_xml_encoding = 'utf-8'
-                xml_data = unicode(xml_data[3:], 'utf-8').encode('utf-8')
-            else:
-                sniffed_xml_encoding = 'ascii'
-                pass
-        except:
-            xml_encoding_match = None
-        xml_encoding_match = re.compile(
-            '^<\?.*encoding=[\'"](.*?)[\'"].*\?>').match(xml_data)
-        if not xml_encoding_match and isHTML:
-            regexp = re.compile('<\s*meta[^>]+charset=([^>]*?)[;\'">]', re.I)
-            xml_encoding_match = regexp.search(xml_data)
-        if xml_encoding_match is not None:
-            xml_encoding = xml_encoding_match.groups()[0].lower()
-            if isHTML:
-                self.declaredHTMLEncoding = xml_encoding
-            if sniffed_xml_encoding and \
-               (xml_encoding in ('iso-10646-ucs-2', 'ucs-2', 'csunicode',
-                                 'iso-10646-ucs-4', 'ucs-4', 'csucs4',
-                                 'utf-16', 'utf-32', 'utf_16', 'utf_32',
-                                 'utf16', 'u16')):
-                xml_encoding = sniffed_xml_encoding
-        return xml_data, xml_encoding, sniffed_xml_encoding
-
-
-    def find_codec(self, charset):
-        return self._codec(self.CHARSET_ALIASES.get(charset, charset)) \
-               or (charset and self._codec(charset.replace("-", ""))) \
-               or (charset and self._codec(charset.replace("-", "_"))) \
-               or charset
-
-    def _codec(self, charset):
-        if not charset: return charset
-        codec = None
-        try:
-            codecs.lookup(charset)
-            codec = charset
-        except (LookupError, ValueError):
-            pass
-        return codec
-
-    EBCDIC_TO_ASCII_MAP = None
-    def _ebcdic_to_ascii(self, s):
-        c = self.__class__
-        if not c.EBCDIC_TO_ASCII_MAP:
-            emap = (0,1,2,3,156,9,134,127,151,141,142,11,12,13,14,15,
-                    16,17,18,19,157,133,8,135,24,25,146,143,28,29,30,31,
-                    128,129,130,131,132,10,23,27,136,137,138,139,140,5,6,7,
-                    144,145,22,147,148,149,150,4,152,153,154,155,20,21,158,26,
-                    32,160,161,162,163,164,165,166,167,168,91,46,60,40,43,33,
-                    38,169,170,171,172,173,174,175,176,177,93,36,42,41,59,94,
-                    45,47,178,179,180,181,182,183,184,185,124,44,37,95,62,63,
-                    186,187,188,189,190,191,192,193,194,96,58,35,64,39,61,34,
-                    195,97,98,99,100,101,102,103,104,105,196,197,198,199,200,
-                    201,202,106,107,108,109,110,111,112,113,114,203,204,205,
-                    206,207,208,209,126,115,116,117,118,119,120,121,122,210,
-                    211,212,213,214,215,216,217,218,219,220,221,222,223,224,
-                    225,226,227,228,229,230,231,123,65,66,67,68,69,70,71,72,
-                    73,232,233,234,235,236,237,125,74,75,76,77,78,79,80,81,
-                    82,238,239,240,241,242,243,92,159,83,84,85,86,87,88,89,
-                    90,244,245,246,247,248,249,48,49,50,51,52,53,54,55,56,57,
-                    250,251,252,253,254,255)
-            import string
-            c.EBCDIC_TO_ASCII_MAP = string.maketrans( \
-            ''.join(map(chr, range(256))), ''.join(map(chr, emap)))
-        return s.translate(c.EBCDIC_TO_ASCII_MAP)
-
-    MS_CHARS = { '\x80' : ('euro', '20AC'),
-                 '\x81' : ' ',
-                 '\x82' : ('sbquo', '201A'),
-                 '\x83' : ('fnof', '192'),
-                 '\x84' : ('bdquo', '201E'),
-                 '\x85' : ('hellip', '2026'),
-                 '\x86' : ('dagger', '2020'),
-                 '\x87' : ('Dagger', '2021'),
-                 '\x88' : ('circ', '2C6'),
-                 '\x89' : ('permil', '2030'),
-                 '\x8A' : ('Scaron', '160'),
-                 '\x8B' : ('lsaquo', '2039'),
-                 '\x8C' : ('OElig', '152'),
-                 '\x8D' : '?',
-                 '\x8E' : ('#x17D', '17D'),
-                 '\x8F' : '?',
-                 '\x90' : '?',
-                 '\x91' : ('lsquo', '2018'),
-                 '\x92' : ('rsquo', '2019'),
-                 '\x93' : ('ldquo', '201C'),
-                 '\x94' : ('rdquo', '201D'),
-                 '\x95' : ('bull', '2022'),
-                 '\x96' : ('ndash', '2013'),
-                 '\x97' : ('mdash', '2014'),
-                 '\x98' : ('tilde', '2DC'),
-                 '\x99' : ('trade', '2122'),
-                 '\x9a' : ('scaron', '161'),
-                 '\x9b' : ('rsaquo', '203A'),
-                 '\x9c' : ('oelig', '153'),
-                 '\x9d' : '?',
-                 '\x9e' : ('#x17E', '17E'),
-                 '\x9f' : ('Yuml', ''),}
-
-#######################################################################
-
-
-#By default, act as an HTML pretty-printer.
-if __name__ == '__main__':
-    import sys
-    soup = BeautifulSoup(sys.stdin)
-    print soup.prettify()
diff --git a/module/lib/MultipartPostHandler.py b/module/lib/MultipartPostHandler.py
deleted file mode 100644
index 94aee0193..000000000
--- a/module/lib/MultipartPostHandler.py
+++ /dev/null
@@ -1,139 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-####
-# 02/2006 Will Holcomb <wholcomb@gmail.com>
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License, or (at your option) any later version.
-#
-# This library 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
-# Lesser General Public License for more details.
-#
-# 7/26/07 Slightly modified by Brian Schneider
-# in order to support unicode files ( multipart_encode function )
-"""
-Usage:
-  Enables the use of multipart/form-data for posting forms
-
-Inspirations:
-  Upload files in python:
-    http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/146306
-  urllib2_file:
-    Fabien Seisen: <fabien@seisen.org>
-
-Example:
-  import MultipartPostHandler, urllib2, cookielib
-
-  cookies = cookielib.CookieJar()
-  opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cookies),
-                                MultipartPostHandler.MultipartPostHandler)
-  params = { "username" : "bob", "password" : "riviera",
-             "file" : open("filename", "rb") }
-  opener.open("http://wwww.bobsite.com/upload/", params)
-
-Further Example:
-  The main function of this file is a sample which downloads a page and
-  then uploads it to the W3C validator.
-"""
-
-from urllib import urlencode
-from urllib2 import BaseHandler, HTTPHandler, build_opener
-import mimetools, mimetypes
-from os import write, remove
-from cStringIO import StringIO
-
-class Callable:
-    def __init__(self, anycallable):
-        self.__call__ = anycallable
-
-# Controls how sequences are uncoded. If true, elements may be given multiple values by
-#  assigning a sequence.
-doseq = 1
-
-class MultipartPostHandler(BaseHandler):
-    handler_order = HTTPHandler.handler_order - 10 # needs to run first
-
-    def http_request(self, request):
-        data = request.get_data()
-        if data is not None and type(data) != str:
-            v_files = []
-            v_vars = []
-            try:
-                 for(key, value) in data.items():
-                     if type(value) == file:
-                         v_files.append((key, value))
-                     else:
-                         v_vars.append((key, value))
-            except TypeError:
-                systype, value, traceback = sys.exc_info()
-                raise TypeError, "not a valid non-string sequence or mapping object", traceback
-
-            if len(v_files) == 0:
-                data = urlencode(v_vars, doseq)
-            else:
-                boundary, data = self.multipart_encode(v_vars, v_files)
-
-                contenttype = 'multipart/form-data; boundary=%s' % boundary
-                if(request.has_header('Content-Type')
-                   and request.get_header('Content-Type').find('multipart/form-data') != 0):
-                    print "Replacing %s with %s" % (request.get_header('content-type'), 'multipart/form-data')
-                request.add_unredirected_header('Content-Type', contenttype)
-
-            request.add_data(data)
-
-        return request
-
-    def multipart_encode(vars, files, boundary = None, buf = None):
-        if boundary is None:
-            boundary = mimetools.choose_boundary()
-        if buf is None:
-            buf = StringIO()
-        for(key, value) in vars:
-            buf.write('--%s\r\n' % boundary)
-            buf.write('Content-Disposition: form-data; name="%s"' % key)
-            buf.write('\r\n\r\n' + value + '\r\n')
-        for(key, fd) in files:
-            #file_size = os.fstat(fd.fileno())[stat.ST_SIZE]
-            filename = fd.name.split('/')[-1]
-            contenttype = mimetypes.guess_type(filename)[0] or 'application/octet-stream'
-            buf.write('--%s\r\n' % boundary)
-            buf.write('Content-Disposition: form-data; name="%s"; filename="%s"\r\n' % (key, filename))
-            buf.write('Content-Type: %s\r\n' % contenttype)
-            # buffer += 'Content-Length: %s\r\n' % file_size
-            fd.seek(0)
-            buf.write('\r\n' + fd.read() + '\r\n')
-        buf.write('--' + boundary + '--\r\n\r\n')
-        buf = buf.getvalue()
-        return boundary, buf
-    multipart_encode = Callable(multipart_encode)
-
-    https_request = http_request
-
-def main():
-    import tempfile, sys
-
-    validatorURL = "http://validator.w3.org/check"
-    opener = build_opener(MultipartPostHandler)
-
-    def validateFile(url):
-        temp = tempfile.mkstemp(suffix=".html")
-        write(temp[0], opener.open(url).read())
-        params = { "ss" : "0",            # show source
-                   "doctype" : "Inline",
-                   "uploaded_file" : open(temp[1], "rb") }
-        print opener.open(validatorURL, params).read()
-        remove(temp[1])
-
-    if len(sys.argv[1:]) > 0:
-        for arg in sys.argv[1:]:
-            validateFile(arg)
-    else:
-        validateFile("http://www.google.com")
-
-if __name__=="__main__":
-    main()
diff --git a/module/lib/ReadWriteLock.py b/module/lib/ReadWriteLock.py
new file mode 100644
index 000000000..cc82f3d48
--- /dev/null
+++ b/module/lib/ReadWriteLock.py
@@ -0,0 +1,232 @@
+# -*- coding: iso-8859-15 -*-
+"""locks.py - Read-Write lock thread lock implementation
+
+See the class documentation for more info.
+
+Copyright (C) 2007, Heiko Wundram.
+Released under the BSD-license.
+
+http://code.activestate.com/recipes/502283-read-write-lock-class-rlock-like/
+"""
+
+# Imports
+# -------
+
+from threading import Condition, Lock, currentThread
+from time import time
+
+
+# Read write lock
+# ---------------
+
+class ReadWriteLock(object):
+    """Read-Write lock class. A read-write lock differs from a standard
+    threading.RLock() by allowing multiple threads to simultaneously hold a
+    read lock, while allowing only a single thread to hold a write lock at the
+    same point of time.
+
+    When a read lock is requested while a write lock is held, the reader
+    is blocked; when a write lock is requested while another write lock is
+    held or there are read locks, the writer is blocked.
+
+    Writers are always preferred by this implementation: if there are blocked
+    threads waiting for a write lock, current readers may request more read
+    locks (which they eventually should free, as they starve the waiting
+    writers otherwise), but a new thread requesting a read lock will not
+    be granted one, and block. This might mean starvation for readers if
+    two writer threads interweave their calls to acquireWrite() without
+    leaving a window only for readers.
+
+    In case a current reader requests a write lock, this can and will be
+    satisfied without giving up the read locks first, but, only one thread
+    may perform this kind of lock upgrade, as a deadlock would otherwise
+    occur. After the write lock has been granted, the thread will hold a
+    full write lock, and not be downgraded after the upgrading call to
+    acquireWrite() has been match by a corresponding release().
+    """
+
+    def __init__(self):
+        """Initialize this read-write lock."""
+
+        # Condition variable, used to signal waiters of a change in object
+        # state.
+        self.__condition = Condition(Lock())
+
+        # Initialize with no writers.
+        self.__writer = None
+        self.__upgradewritercount = 0
+        self.__pendingwriters = []
+
+        # Initialize with no readers.
+        self.__readers = {}
+
+    def acquire(self, blocking=True, timeout=None, shared=False):
+        if shared:
+            self.acquireRead(timeout)
+        else:
+            self.acquireWrite(timeout)
+
+    def acquireRead(self, timeout=None):
+        """Acquire a read lock for the current thread, waiting at most
+        timeout seconds or doing a non-blocking check in case timeout is <= 0.
+
+        In case timeout is None, the call to acquireRead blocks until the
+        lock request can be serviced.
+
+        In case the timeout expires before the lock could be serviced, a
+        RuntimeError is thrown."""
+
+        if timeout is not None:
+            endtime = time() + timeout
+        me = currentThread()
+        self.__condition.acquire()
+        try:
+            if self.__writer is me:
+                # If we are the writer, grant a new read lock, always.
+                self.__writercount += 1
+                return
+            while True:
+                if self.__writer is None:
+                    # Only test anything if there is no current writer.
+                    if self.__upgradewritercount or self.__pendingwriters:
+                        if me in self.__readers:
+                            # Only grant a read lock if we already have one
+                            # in case writers are waiting for their turn.
+                            # This means that writers can't easily get starved
+                            # (but see below, readers can).
+                            self.__readers[me] += 1
+                            return
+                            # No, we aren't a reader (yet), wait for our turn.
+                    else:
+                        # Grant a new read lock, always, in case there are
+                        # no pending writers (and no writer).
+                        self.__readers[me] = self.__readers.get(me, 0) + 1
+                        return
+                if timeout is not None:
+                    remaining = endtime - time()
+                    if remaining <= 0:
+                        # Timeout has expired, signal caller of this.
+                        raise RuntimeError("Acquiring read lock timed out")
+                    self.__condition.wait(remaining)
+                else:
+                    self.__condition.wait()
+        finally:
+            self.__condition.release()
+
+    def acquireWrite(self, timeout=None):
+        """Acquire a write lock for the current thread, waiting at most
+        timeout seconds or doing a non-blocking check in case timeout is <= 0.
+
+        In case the write lock cannot be serviced due to the deadlock
+        condition mentioned above, a ValueError is raised.
+
+        In case timeout is None, the call to acquireWrite blocks until the
+        lock request can be serviced.
+
+        In case the timeout expires before the lock could be serviced, a
+        RuntimeError is thrown."""
+
+        if timeout is not None:
+            endtime = time() + timeout
+        me, upgradewriter = currentThread(), False
+        self.__condition.acquire()
+        try:
+            if self.__writer is me:
+                # If we are the writer, grant a new write lock, always.
+                self.__writercount += 1
+                return
+            elif me in self.__readers:
+                # If we are a reader, no need to add us to pendingwriters,
+                # we get the upgradewriter slot.
+                if self.__upgradewritercount:
+                    # If we are a reader and want to upgrade, and someone
+                    # else also wants to upgrade, there is no way we can do
+                    # this except if one of us releases all his read locks.
+                    # Signal this to user.
+                    raise ValueError(
+                        "Inevitable dead lock, denying write lock"
+                    )
+                upgradewriter = True
+                self.__upgradewritercount = self.__readers.pop(me)
+            else:
+                # We aren't a reader, so add us to the pending writers queue
+                # for synchronization with the readers.
+                self.__pendingwriters.append(me)
+            while True:
+                if not self.__readers and self.__writer is None:
+                    # Only test anything if there are no readers and writers.
+                    if self.__upgradewritercount:
+                        if upgradewriter:
+                            # There is a writer to upgrade, and it's us. Take
+                            # the write lock.
+                            self.__writer = me
+                            self.__writercount = self.__upgradewritercount + 1
+                            self.__upgradewritercount = 0
+                            return
+                            # There is a writer to upgrade, but it's not us.
+                            # Always leave the upgrade writer the advance slot,
+                            # because he presumes he'll get a write lock directly
+                            # from a previously held read lock.
+                    elif self.__pendingwriters[0] is me:
+                        # If there are no readers and writers, it's always
+                        # fine for us to take the writer slot, removing us
+                        # from the pending writers queue.
+                        # This might mean starvation for readers, though.
+                        self.__writer = me
+                        self.__writercount = 1
+                        self.__pendingwriters = self.__pendingwriters[1:]
+                        return
+                if timeout is not None:
+                    remaining = endtime - time()
+                    if remaining <= 0:
+                        # Timeout has expired, signal caller of this.
+                        if upgradewriter:
+                            # Put us back on the reader queue. No need to
+                            # signal anyone of this change, because no other
+                            # writer could've taken our spot before we got
+                            # here (because of remaining readers), as the test
+                            # for proper conditions is at the start of the
+                            # loop, not at the end.
+                            self.__readers[me] = self.__upgradewritercount
+                            self.__upgradewritercount = 0
+                        else:
+                            # We were a simple pending writer, just remove us
+                            # from the FIFO list.
+                            self.__pendingwriters.remove(me)
+                        raise RuntimeError("Acquiring write lock timed out")
+                    self.__condition.wait(remaining)
+                else:
+                    self.__condition.wait()
+        finally:
+            self.__condition.release()
+
+    def release(self):
+        """Release the currently held lock.
+
+        In case the current thread holds no lock, a ValueError is thrown."""
+
+        me = currentThread()
+        self.__condition.acquire()
+        try:
+            if self.__writer is me:
+                # We are the writer, take one nesting depth away.
+                self.__writercount -= 1
+                if not self.__writercount:
+                    # No more write locks; take our writer position away and
+                    # notify waiters of the new circumstances.
+                    self.__writer = None
+                    self.__condition.notifyAll()
+            elif me in self.__readers:
+                # We are a reader currently, take one nesting depth away.
+                self.__readers[me] -= 1
+                if not self.__readers[me]:
+                    # No more read locks, take our reader position away.
+                    del self.__readers[me]
+                    if not self.__readers:
+                        # No more readers, notify waiters of the new
+                        # circumstances.
+                        self.__condition.notifyAll()
+            else:
+                raise ValueError("Trying to release unheld lock")
+        finally:
+            self.__condition.release()
diff --git a/module/lib/Unzip.py b/module/lib/Unzip.py
deleted file mode 100644
index f56fbe751..000000000
--- a/module/lib/Unzip.py
+++ /dev/null
@@ -1,50 +0,0 @@
-import zipfile
-import os
-
-class Unzip:
-    def __init__(self):
-        pass
-        
-    def extract(self, file, dir):
-        if not dir.endswith(':') and not os.path.exists(dir):
-            os.mkdir(dir)
-
-        zf = zipfile.ZipFile(file)
-
-        # create directory structure to house files
-        self._createstructure(file, dir)
-
-        # extract files to directory structure
-        for i, name in enumerate(zf.namelist()):
-
-            if not name.endswith('/') and not name.endswith("config"):
-                print "extracting", name.replace("pyload/","")
-                outfile = open(os.path.join(dir, name.replace("pyload/","")), 'wb')
-                outfile.write(zf.read(name))
-                outfile.flush()
-                outfile.close()
-
-    def _createstructure(self, file, dir):
-        self._makedirs(self._listdirs(file), dir)
-
-    def _makedirs(self, directories, basedir):
-        """ Create any directories that don't currently exist """
-        for dir in directories:
-            curdir = os.path.join(basedir, dir)
-            if not os.path.exists(curdir):
-                os.mkdir(curdir)
-
-    def _listdirs(self, file):
-        """ Grabs all the directories in the zip structure
-        This is necessary to create the structure before trying
-        to extract the file to it. """
-        zf = zipfile.ZipFile(file)
-
-        dirs = []
-
-        for name in zf.namelist():
-            if name.endswith('/'):
-                dirs.append(name.replace("pyload/",""))
-
-        dirs.sort()
-        return dirs
diff --git a/module/lib/bottle.py b/module/lib/bottle.py
index 2c243278e..b00bda1c9 100644
--- a/module/lib/bottle.py
+++ b/module/lib/bottle.py
@@ -9,14 +9,14 @@ Python Standard Library.
 
 Homepage and documentation: http://bottlepy.org/
 
-Copyright (c) 2011, Marcel Hellkamp.
-License: MIT (see LICENSE.txt for details)
+Copyright (c) 2012, Marcel Hellkamp.
+License: MIT (see LICENSE for details)
 """
 
 from __future__ import with_statement
 
 __author__ = 'Marcel Hellkamp'
-__version__ = '0.10.2'
+__version__ = '0.11.4'
 __license__ = 'MIT'
 
 # The gevent server adapter needs to patch some modules before they are imported
@@ -35,102 +35,111 @@ if __name__ == '__main__':
     if _cmd_options.server and _cmd_options.server.startswith('gevent'):
         import gevent.monkey; gevent.monkey.patch_all()
 
-import sys
-import base64
-import cgi
-import email.utils
-import functools
-import hmac
-import httplib
-import imp
-import itertools
-import mimetypes
-import os
-import re
-import subprocess
-import tempfile
-import thread
-import threading
-import time
-import warnings
-
-from Cookie import SimpleCookie
+import base64, cgi, email.utils, functools, hmac, imp, itertools, mimetypes,\
+        os, re, subprocess, sys, tempfile, threading, time, urllib, warnings
+
 from datetime import date as datedate, datetime, timedelta
 from tempfile import TemporaryFile
 from traceback import format_exc, print_exc
-from urlparse import urljoin, SplitResult as UrlSplitResult
-
-# Workaround for a bug in some versions of lib2to3 (fixed on CPython 2.7 and 3.2)
-import urllib
-urlencode = urllib.urlencode
-urlquote = urllib.quote
-urlunquote = urllib.unquote
-
-try: from collections import MutableMapping as DictMixin
-except ImportError: # pragma: no cover
-    from UserDict import DictMixin
-
-try: from urlparse import parse_qs
-except ImportError: # pragma: no cover
-    from cgi import parse_qs
-
-try: import cPickle as pickle
-except ImportError: # pragma: no cover
-    import pickle
 
 try: from json import dumps as json_dumps, loads as json_lds
 except ImportError: # pragma: no cover
     try: from simplejson import dumps as json_dumps, loads as json_lds
-    except ImportError: # pragma: no cover
+    except ImportError:
         try: from django.utils.simplejson import dumps as json_dumps, loads as json_lds
-        except ImportError: # pragma: no cover
+        except ImportError:
             def json_dumps(data):
                 raise ImportError("JSON support requires Python 2.6 or simplejson.")
             json_lds = json_dumps
 
-py3k = sys.version_info >= (3,0,0)
-NCTextIOWrapper = None
 
-if py3k: # pragma: no cover
-    json_loads = lambda s: json_lds(touni(s))
-    # See Request.POST
+
+# We now try to fix 2.5/2.6/3.1/3.2 incompatibilities.
+# It ain't pretty but it works... Sorry for the mess.
+
+py   = sys.version_info
+py3k = py >= (3,0,0)
+py25 = py <  (2,6,0)
+py31 = (3,1,0) <= py < (3,2,0)
+
+# Workaround for the missing "as" keyword in py3k.
+def _e(): return sys.exc_info()[1]
+
+# Workaround for the "print is a keyword/function" Python 2/3 dilemma
+# and a fallback for mod_wsgi (resticts stdout/err attribute access)
+try:
+    _stdout, _stderr = sys.stdout.write, sys.stderr.write
+except IOError:
+    _stdout = lambda x: sys.stdout.write(x)
+    _stderr = lambda x: sys.stderr.write(x)
+
+# Lots of stdlib and builtin differences.
+if py3k:
+    import http.client as httplib
+    import _thread as thread
+    from urllib.parse import urljoin, SplitResult as UrlSplitResult
+    from urllib.parse import urlencode, quote as urlquote, unquote as urlunquote
+    urlunquote = functools.partial(urlunquote, encoding='latin1')
+    from http.cookies import SimpleCookie
+    from collections import MutableMapping as DictMixin
+    import pickle
     from io import BytesIO
-    def touni(x, enc='utf8', err='strict'):
-        """ Convert anything to unicode """
-        return str(x, enc, err) if isinstance(x, bytes) else str(x)
-    if sys.version_info < (3,2,0):
-        from io import TextIOWrapper
-        class NCTextIOWrapper(TextIOWrapper):
-            ''' Garbage collecting an io.TextIOWrapper(buffer) instance closes
-                the wrapped buffer. This subclass keeps it open. '''
-            def close(self): pass
-else:
-    json_loads = json_lds
+    basestring = str
+    unicode = str
+    json_loads = lambda s: json_lds(touni(s))
+    callable = lambda x: hasattr(x, '__call__')
+    imap = map
+else: # 2.x
+    import httplib
+    import thread
+    from urlparse import urljoin, SplitResult as UrlSplitResult
+    from urllib import urlencode, quote as urlquote, unquote as urlunquote
+    from Cookie import SimpleCookie
+    from itertools import imap
+    import cPickle as pickle
     from StringIO import StringIO as BytesIO
-    bytes = str
-    def touni(x, enc='utf8', err='strict'):
-        """ Convert anything to unicode """
-        return x if isinstance(x, unicode) else unicode(str(x), enc, err)
-
-def tob(data, enc='utf8'):
-    """ Convert anything to bytes """
-    return data.encode(enc) if isinstance(data, unicode) else bytes(data)
+    if py25:
+        from UserDict import DictMixin
+        def next(it): return it.next()
+        bytes = str
+    else: # 2.6, 2.7
+        from collections import MutableMapping as DictMixin
+    json_loads = json_lds
 
+# Some helpers for string/byte handling
+def tob(s, enc='utf8'):
+    return s.encode(enc) if isinstance(s, unicode) else bytes(s)
+def touni(s, enc='utf8', err='strict'):
+    return s.decode(enc, err) if isinstance(s, bytes) else unicode(s)
 tonat = touni if py3k else tob
-tonat.__doc__ = """ Convert anything to native strings """
 
-def try_update_wrapper(wrapper, wrapped, *a, **ka):
-    try: # Bug: functools breaks if wrapper is an instane method
-        functools.update_wrapper(wrapper, wrapped, *a, **ka)
+# 3.2 fixes cgi.FieldStorage to accept bytes (which makes a lot of sense).
+# 3.1 needs a workaround.
+if py31:
+    from io import TextIOWrapper
+    class NCTextIOWrapper(TextIOWrapper):
+        def close(self): pass # Keep wrapped buffer open.
+
+# File uploads (which are implemented as empty FiledStorage instances...)
+# have a negative truth value. That makes no sense, here is a fix.
+class FieldStorage(cgi.FieldStorage):
+    def __nonzero__(self): return bool(self.list or self.file)
+    if py3k: __bool__ = __nonzero__
+
+# A bug in functools causes it to break if the wrapper is an instance method
+def update_wrapper(wrapper, wrapped, *a, **ka):
+    try: functools.update_wrapper(wrapper, wrapped, *a, **ka)
     except AttributeError: pass
 
-# Backward compatibility
+
+
+# These helpers are used at module level and need to be defined first.
+# And yes, I know PEP-8, but sometimes a lower-case classname makes more sense.
+
 def depr(message):
     warnings.warn(message, DeprecationWarning, stacklevel=3)
 
-
-# Small helpers
-def makelist(data):
+def makelist(data): # This is just to handy
     if isinstance(data, (tuple, list, set, dict)): return list(data)
     elif data: return [data]
     else: return []
@@ -161,7 +170,7 @@ class DictProperty(object):
         del getattr(obj, self.attr)[self.key]
 
 
-class CachedProperty(object):
+class cached_property(object):
     ''' A property that is only computed once per instance and then replaces
         itself with an ordinary attribute. Deleting the attribute resets the
         property. '''
@@ -174,10 +183,8 @@ class CachedProperty(object):
         value = obj.__dict__[self.func.__name__] = self.func(obj)
         return value
 
-cached_property = CachedProperty
 
-
-class lazy_attribute(object): # Does not need configuration -> lower-case name
+class lazy_attribute(object):
     ''' A property that caches itself to the class object. '''
     def __init__(self, func):
         functools.update_wrapper(self, func, updated=[])
@@ -203,35 +210,6 @@ class BottleException(Exception):
     pass
 
 
-#TODO: These should subclass BaseRequest
-
-class HTTPResponse(BottleException):
-    """ Used to break execution and immediately finish the response """
-    def __init__(self, output='', status=200, header=None):
-        super(BottleException, self).__init__("HTTP Response %d" % status)
-        self.status = int(status)
-        self.output = output
-        self.headers = HeaderDict(header) if header else None
-
-    def apply(self, response):
-        if self.headers:
-            for key, value in self.headers.iterallitems():
-                response.headers[key] = value
-        response.status = self.status
-
-
-class HTTPError(HTTPResponse):
-    """ Used to generate an error page """
-    def __init__(self, code=500, output='Unknown Error', exception=None,
-                 traceback=None, header=None):
-        super(HTTPError, self).__init__(output, code, header)
-        self.exception = exception
-        self.traceback = traceback
-
-    def __repr__(self):
-        return template(ERROR_PAGE_TEMPLATE, e=self)
-
-
 
 
 
@@ -251,12 +229,15 @@ class RouteReset(BottleException):
 
 class RouterUnknownModeError(RouteError): pass
 
+
 class RouteSyntaxError(RouteError):
     """ The route parser found something not supported by this router """
 
+
 class RouteBuildError(RouteError):
     """ The route could not been built """
 
+
 class Router(object):
     ''' A Router is an ordered collection of route->target pairs. It is used to
         efficiently match WSGI requests against a number of routes and return
@@ -285,7 +266,7 @@ class Router(object):
         #: If true, static routes are no longer checked first.
         self.strict_order = strict
         self.filters = {'re': self.re_filter, 'int': self.int_filter,
-                        'float': self.re_filter, 'path': self.path_filter}
+                        'float': self.float_filter, 'path': self.path_filter}
 
     def re_filter(self, conf):
         return conf or self.default_pattern, None, None
@@ -294,17 +275,17 @@ class Router(object):
         return r'-?\d+', int, lambda x: str(int(x))
 
     def float_filter(self, conf):
-        return r'-?\d*\.\d+', float, lambda x: str(float(x))
+        return r'-?[\d.]+', float, lambda x: str(float(x))
 
     def path_filter(self, conf):
-        return r'.*?', None, None
-    
+        return r'.+?', None, None
+
     def add_filter(self, name, func):
         ''' Add a filter. The provided function is called with the configuration
         string as parameter and must return a (regexp, to_python, to_url) tuple.
         The first element is a string, the last two are callables or None. '''
         self.filters[name] = func
-    
+
     def parse_rule(self, rule):
         ''' Parses a rule into a (name, filter, conf) token stream. If mode is
             None, name contains a static rule part. '''
@@ -366,8 +347,8 @@ class Router(object):
 
         try:
             re_match = re.compile('^(%s)$' % pattern).match
-        except re.error, e:
-            raise RouteSyntaxError("Could not add Route: %s (%s)" % (rule, e))
+        except re.error:
+            raise RouteSyntaxError("Could not add Route: %s (%s)" % (rule, _e()))
 
         def match(path):
             """ Return an url-argument dictionary. """
@@ -383,7 +364,7 @@ class Router(object):
             combined = '%s|(^%s$)' % (self.dynamic[-1][0].pattern, flat_pattern)
             self.dynamic[-1] = (re.compile(combined), self.dynamic[-1][1])
             self.dynamic[-1][1].append((match, target))
-        except (AssertionError, IndexError), e: # AssertionError: Too many groups
+        except (AssertionError, IndexError): # AssertionError: Too many groups
             self.dynamic.append((re.compile('(^%s$)' % flat_pattern),
                                 [(match, target)]))
         return match
@@ -396,8 +377,8 @@ class Router(object):
             for i, value in enumerate(anons): query['anon%d'%i] = value
             url = ''.join([f(query.pop(n)) if n else f for (n,f) in builder])
             return url if not query else url+'?'+urlencode(query)
-        except KeyError, e:
-            raise RouteBuildError('Missing URL argument: %r' % e.args[0])
+        except KeyError:
+            raise RouteBuildError('Missing URL argument: %r' % _e().args[0])
 
     def match(self, environ):
         ''' Return a (target, url_agrs) tuple or raise HTTPError(400/404/405). '''
@@ -424,9 +405,7 @@ class Router(object):
         allowed = [verb for verb in targets if verb != 'ANY']
         if 'GET' in allowed and 'HEAD' not in allowed:
             allowed.append('HEAD')
-        raise HTTPError(405, "Method not allowed.",
-                        header=[('Allow',",".join(allowed))])
-
+        raise HTTPError(405, "Method not allowed.", Allow=",".join(allowed))
 
 
 class Route(object):
@@ -435,7 +414,6 @@ class Route(object):
         turing an URL path rule into a regular expression usable by the Router.
     '''
 
-
     def __init__(self, app, rule, method, callback, name=None,
                  plugins=None, skiplist=None, **config):
         #: The application this route is installed to.
@@ -509,9 +487,12 @@ class Route(object):
             except RouteReset: # Try again with changed configuration.
                 return self._make_callback()
             if not callback is self.callback:
-                try_update_wrapper(callback, self.callback)
+                update_wrapper(callback, self.callback)
         return callback
 
+    def __repr__(self):
+        return '<%s %r %r>' % (self.method, self.rule, self.callback)
+
 
 
 
@@ -523,27 +504,38 @@ class Route(object):
 
 
 class Bottle(object):
-    """ WSGI application """
+    """ Each Bottle object represents a single, distinct web application and
+        consists of routes, callbacks, plugins, resources and configuration.
+        Instances are callable WSGI applications.
+
+        :param catchall: If true (default), handle all exceptions. Turn off to
+                         let debugging middleware handle exceptions.
+    """
+
+    def __init__(self, catchall=True, autojson=True):
+        #: If true, most exceptions are caught and returned as :exc:`HTTPError`
+        self.catchall = catchall
+
+        #: A :class:`ResourceManager` for application files
+        self.resources = ResourceManager()
+
+        #: A :class:`ConfigDict` for app specific configuration.
+        self.config = ConfigDict()
+        self.config.autojson = autojson
 
-    def __init__(self, catchall=True, autojson=True, config=None):
-        """ Create a new bottle instance.
-            You usually don't do that. Use `bottle.app.push()` instead.
-        """
         self.routes = [] # List of installed :class:`Route` instances.
         self.router = Router() # Maps requests to :class:`Route` instances.
-        self.plugins = [] # List of installed plugins.
-
         self.error_handler = {}
-        #: If true, most exceptions are catched and returned as :exc:`HTTPError`
-        self.config = ConfigDict(config or {})
-        self.catchall = catchall
-        #: An instance of :class:`HooksPlugin`. Empty by default.
+
+        # Core plugins
+        self.plugins = [] # List of installed plugins.
         self.hooks = HooksPlugin()
         self.install(self.hooks)
-        if autojson:
+        if self.config.autojson:
             self.install(JSONPlugin())
         self.install(TemplatePlugin())
 
+
     def mount(self, prefix, app, **options):
         ''' Mount an application (:class:`Bottle` or plain WSGI) to a specific
             URL prefix. Example::
@@ -560,14 +552,11 @@ class Bottle(object):
             prefix, app = app, prefix
             depr('Parameter order of Bottle.mount() changed.') # 0.10
 
-        parts = filter(None, prefix.split('/'))
-        if not parts: raise ValueError('Empty path prefix.')
-        path_depth = len(parts)
-        options.setdefault('skip', True)
-        options.setdefault('method', 'ANY')
+        segments = [p for p in prefix.split('/') if p]
+        if not segments: raise ValueError('Empty path prefix.')
+        path_depth = len(segments)
 
-        @self.route('/%s/:#.*#' % '/'.join(parts), **options)
-        def mountpoint():
+        def mountpoint_wrapper():
             try:
                 request.path_shift(path_depth)
                 rs = BaseResponse([], 200)
@@ -575,13 +564,30 @@ class Bottle(object):
                     rs.status = status
                     for name, value in header: rs.add_header(name, value)
                     return rs.body.append
-                rs.body = itertools.chain(rs.body, app(request.environ, start_response))
-                return HTTPResponse(rs.body, rs.status, rs.headers)
+                body = app(request.environ, start_response)
+                body = itertools.chain(rs.body, body)
+                return HTTPResponse(body, rs.status_code, **rs.headers)
             finally:
                 request.path_shift(-path_depth)
 
+        options.setdefault('skip', True)
+        options.setdefault('method', 'ANY')
+        options.setdefault('mountpoint', {'prefix': prefix, 'target': app})
+        options['callback'] = mountpoint_wrapper
+
+        self.route('/%s/<:re:.*>' % '/'.join(segments), **options)
         if not prefix.endswith('/'):
-            self.route('/' + '/'.join(parts), callback=mountpoint, **options)
+            self.route('/' + '/'.join(segments), **options)
+
+    def merge(self, routes):
+        ''' Merge the routes of another :class:`Bottle` application or a list of
+            :class:`Route` objects into this application. The routes keep their
+            'owner', meaning that the :data:`Route.app` attribute is not
+            changed. '''
+        if isinstance(routes, Bottle):
+            routes = routes.routes
+        for route in routes:
+            self.add_route(route)
 
     def install(self, plugin):
         ''' Add a plugin to the list of plugins and prepare it for being
@@ -610,6 +616,10 @@ class Bottle(object):
         if removed: self.reset()
         return removed
 
+    def run(self, **kwargs):
+        ''' Calls :func:`run` with the same parameters. '''
+        run(self, **kwargs)
+
     def reset(self, route=None):
         ''' Reset all routes (force plugins to be re-applied) and clear all
             caches. If an ID or route object is given, only that specific route
@@ -640,6 +650,13 @@ class Bottle(object):
         location = self.router.build(routename, **kargs).lstrip('/')
         return urljoin(urljoin('/', scriptname), location)
 
+    def add_route(self, route):
+        ''' Add a route object, but do not change the :data:`Route.app`
+            attribute.'''
+        self.routes.append(route)
+        self.router.add(route.rule, route.method, route, name=route.name)
+        if DEBUG: route.prepare()
+
     def route(self, path=None, method='GET', callback=None, name=None,
               apply=None, skip=None, **config):
         """ A decorator to bind a function to a request URL. Example::
@@ -678,9 +695,7 @@ class Bottle(object):
                     verb = verb.upper()
                     route = Route(self, rule, verb, callback, name=name,
                                   plugins=plugins, skiplist=skiplist, **config)
-                    self.routes.append(route)
-                    self.router.add(rule, verb, route, name=name)
-                    if DEBUG: route.prepare()
+                    self.add_route(route)
             return callback
         return decorator(callback) if callback else decorator
 
@@ -708,7 +723,13 @@ class Bottle(object):
         return wrapper
 
     def hook(self, name):
-        """ Return a decorator that attaches a callback to a hook. """
+        """ Return a decorator that attaches a callback to a hook. Three hooks
+            are currently implemented:
+
+            - before_request: Executed once before each request
+            - after_request: Executed once after each request
+            - app_reset: Called whenever :meth:`reset` is called.
+        """
         def wrapper(func):
             self.hooks.add(name, func)
             return func
@@ -716,8 +737,8 @@ class Bottle(object):
 
     def handle(self, path, method='GET'):
         """ (deprecated) Execute the first matching route callback and return
-            the result. :exc:`HTTPResponse` exceptions are catched and returned.
-            If :attr:`Bottle.catchall` is true, other exceptions are catched as
+            the result. :exc:`HTTPResponse` exceptions are caught and returned.
+            If :attr:`Bottle.catchall` is true, other exceptions are caught as
             well and returned as :exc:`HTTPError` instances (500).
         """
         depr("This method will change semantics in 0.10. Try to avoid it.")
@@ -725,26 +746,33 @@ class Bottle(object):
             return self._handle(path)
         return self._handle({'PATH_INFO': path, 'REQUEST_METHOD': method.upper()})
 
+    def default_error_handler(self, res):
+        return tob(template(ERROR_PAGE_TEMPLATE, e=res))
+
     def _handle(self, environ):
         try:
+            environ['bottle.app'] = self
+            request.bind(environ)
+            response.bind()
             route, args = self.router.match(environ)
-            environ['route.handle'] = environ['bottle.route'] = route
+            environ['route.handle'] = route
+            environ['bottle.route'] = route
             environ['route.url_args'] = args
             return route.call(**args)
-        except HTTPResponse, r:
-            return r
+        except HTTPResponse:
+            return _e()
         except RouteReset:
             route.reset()
             return self._handle(environ)
         except (KeyboardInterrupt, SystemExit, MemoryError):
             raise
-        except Exception, e:
+        except Exception:
             if not self.catchall: raise
-            stacktrace = format_exc(10)
+            stacktrace = format_exc()
             environ['wsgi.errors'].write(stacktrace)
-            return HTTPError(500, "Internal Server Error", e, stacktrace)
+            return HTTPError(500, "Internal Server Error", _e(), stacktrace)
 
-    def _cast(self, out, request, response, peek=None):
+    def _cast(self, out, peek=None):
         """ Try to convert the parameter into something WSGI compatible and set
         correct HTTP headers when possible.
         Support: False, str, unicode, dict, HTTPResponse, HTTPError, file-like,
@@ -753,7 +781,8 @@ class Bottle(object):
 
         # Empty output is done here
         if not out:
-            response['Content-Length'] = 0
+            if 'Content-Length' not in response:
+                response['Content-Length'] = 0
             return []
         # Join lists of byte or unicode strings. Mixed lists are NOT supported
         if isinstance(out, (tuple, list))\
@@ -764,19 +793,18 @@ class Bottle(object):
             out = out.encode(response.charset)
         # Byte Strings are just returned
         if isinstance(out, bytes):
-            response['Content-Length'] = len(out)
+            if 'Content-Length' not in response:
+                response['Content-Length'] = len(out)
             return [out]
         # HTTPError or HTTPException (recursive, because they may wrap anything)
         # TODO: Handle these explicitly in handle() or make them iterable.
         if isinstance(out, HTTPError):
             out.apply(response)
-            out = self.error_handler.get(out.status, repr)(out)
-            if isinstance(out, HTTPResponse):
-                depr('Error handlers must not return :exc:`HTTPResponse`.') #0.9
-            return self._cast(out, request, response)
+            out = self.error_handler.get(out.status_code, self.default_error_handler)(out)
+            return self._cast(out)
         if isinstance(out, HTTPResponse):
             out.apply(response)
-            return self._cast(out.output, request, response)
+            return self._cast(out.body)
 
         # File-like objects.
         if hasattr(out, 'read'):
@@ -788,54 +816,54 @@ class Bottle(object):
         # Handle Iterables. We peek into them to detect their inner type.
         try:
             out = iter(out)
-            first = out.next()
+            first = next(out)
             while not first:
-                first = out.next()
+                first = next(out)
         except StopIteration:
-            return self._cast('', request, response)
-        except HTTPResponse, e:
-            first = e
-        except Exception, e:
-            first = HTTPError(500, 'Unhandled exception', e, format_exc(10))
-            if isinstance(e, (KeyboardInterrupt, SystemExit, MemoryError))\
-            or not self.catchall:
-                raise
+            return self._cast('')
+        except HTTPResponse:
+            first = _e()
+        except (KeyboardInterrupt, SystemExit, MemoryError):
+            raise
+        except Exception:
+            if not self.catchall: raise
+            first = HTTPError(500, 'Unhandled exception', _e(), format_exc())
+
         # These are the inner types allowed in iterator or generator objects.
         if isinstance(first, HTTPResponse):
-            return self._cast(first, request, response)
+            return self._cast(first)
         if isinstance(first, bytes):
             return itertools.chain([first], out)
         if isinstance(first, unicode):
-            return itertools.imap(lambda x: x.encode(response.charset),
+            return imap(lambda x: x.encode(response.charset),
                                   itertools.chain([first], out))
         return self._cast(HTTPError(500, 'Unsupported response type: %s'\
-                                         % type(first)), request, response)
+                                         % type(first)))
 
     def wsgi(self, environ, start_response):
         """ The bottle WSGI-interface. """
         try:
-            environ['bottle.app'] = self
-            request.bind(environ)
-            response.bind()
-            out = self._cast(self._handle(environ), request, response)
+            out = self._cast(self._handle(environ))
             # rfc2616 section 4.3
             if response._status_code in (100, 101, 204, 304)\
-            or request.method == 'HEAD':
+            or environ['REQUEST_METHOD'] == 'HEAD':
                 if hasattr(out, 'close'): out.close()
                 out = []
-            start_response(response._status_line, list(response.iter_headers()))
+            start_response(response._status_line, response.headerlist)
             return out
         except (KeyboardInterrupt, SystemExit, MemoryError):
             raise
-        except Exception, e:
+        except Exception:
             if not self.catchall: raise
             err = '<h1>Critical error while processing request: %s</h1>' \
-                  % environ.get('PATH_INFO', '/')
+                  % html_escape(environ.get('PATH_INFO', '/'))
             if DEBUG:
-                err += '<h2>Error:</h2>\n<pre>%s</pre>\n' % repr(e)
-                err += '<h2>Traceback:</h2>\n<pre>%s</pre>\n' % format_exc(10)
-            environ['wsgi.errors'].write(err) #TODO: wsgi.error should not get html
-            start_response('500 INTERNAL SERVER ERROR', [('Content-Type', 'text/html')])
+                err += '<h2>Error:</h2>\n<pre>\n%s\n</pre>\n' \
+                       '<h2>Traceback:</h2>\n<pre>\n%s\n</pre>\n' \
+                       % (html_escape(repr(_e())), html_escape(format_exc()))
+            environ['wsgi.errors'].write(err)
+            headers = [('Content-Type', 'text/html; charset=UTF-8')]
+            start_response('500 INTERNAL SERVER ERROR', headers)
             return [tob(err)]
 
     def __call__(self, environ, start_response):
@@ -852,19 +880,33 @@ class Bottle(object):
 ###############################################################################
 
 
-class BaseRequest(DictMixin):
+class BaseRequest(object):
     """ A wrapper for WSGI environment dictionaries that adds a lot of
-        convenient access methods and properties. Most of them are read-only."""
+        convenient access methods and properties. Most of them are read-only.
+
+        Adding new attributes to a request actually adds them to the environ
+        dictionary (as 'bottle.request.ext.<name>'). This is the recommended
+        way to store and access request-specific data.
+    """
+
+    __slots__ = ('environ')
 
     #: Maximum size of memory buffer for :attr:`body` in bytes.
     MEMFILE_MAX = 102400
+    #: Maximum number pr GET or POST parameters per request
+    MAX_PARAMS  = 100
 
-    def __init__(self, environ):
+    def __init__(self, environ=None):
         """ Wrap a WSGI environ dictionary. """
         #: The wrapped WSGI environ dictionary. This is the only real attribute.
         #: All other attributes actually are read-only properties.
-        self.environ = environ
-        environ['bottle.request'] = self
+        self.environ = {} if environ is None else environ
+        self.environ['bottle.request'] = self
+
+    @DictProperty('environ', 'bottle.app', read_only=True)
+    def app(self):
+        ''' Bottle application handling this request. '''
+        raise RuntimeError('This request is not connected to an application.')
 
     @property
     def path(self):
@@ -892,7 +934,8 @@ class BaseRequest(DictMixin):
         """ Cookies parsed into a :class:`FormsDict`. Signed cookies are NOT
             decoded. Use :meth:`get_cookie` if you expect signed cookies. """
         cookies = SimpleCookie(self.environ.get('HTTP_COOKIE',''))
-        return FormsDict((c.key, c.value) for c in cookies.itervalues())
+        cookies = list(cookies.values())[:self.MAX_PARAMS]
+        return FormsDict((c.key, c.value) for c in cookies)
 
     def get_cookie(self, key, default=None, secret=None):
         """ Return the content of a cookie. To read a `Signed Cookie`, the
@@ -911,11 +954,10 @@ class BaseRequest(DictMixin):
             values are sometimes called "URL arguments" or "GET parameters", but
             not to be confused with "URL wildcards" as they are provided by the
             :class:`Router`. '''
-        data = parse_qs(self.query_string, keep_blank_values=True)
         get = self.environ['bottle.get'] = FormsDict()
-        for key, values in data.iteritems():
-            for value in values:
-                get[key] = value
+        pairs = _parse_qsl(self.environ.get('QUERY_STRING', ''))
+        for key, value in pairs[:self.MAX_PARAMS]:
+            get[key] = value
         return get
 
     @DictProperty('environ', 'bottle.request.forms', read_only=True)
@@ -925,7 +967,7 @@ class BaseRequest(DictMixin):
             :class:`FormsDict`. All keys and values are strings. File uploads
             are stored separately in :attr:`files`. """
         forms = FormsDict()
-        for name, item in self.POST.iterallitems():
+        for name, item in self.POST.allitems():
             if not hasattr(item, 'filename'):
                 forms[name] = item
         return forms
@@ -935,9 +977,9 @@ class BaseRequest(DictMixin):
         """ A :class:`FormsDict` with the combined values of :attr:`query` and
             :attr:`forms`. File uploads are stored in :attr:`files`. """
         params = FormsDict()
-        for key, value in self.query.iterallitems():
+        for key, value in self.query.allitems():
             params[key] = value
-        for key, value in self.forms.iterallitems():
+        for key, value in self.forms.allitems():
             params[key] = value
         return params
 
@@ -959,7 +1001,7 @@ class BaseRequest(DictMixin):
                 on big files.
         """
         files = FormsDict()
-        for name, item in self.POST.iterallitems():
+        for name, item in self.POST.allitems():
             if hasattr(item, 'filename'):
                 files[name] = item
         return files
@@ -1009,15 +1051,26 @@ class BaseRequest(DictMixin):
             instances of :class:`cgi.FieldStorage` (file uploads).
         """
         post = FormsDict()
+        # We default to application/x-www-form-urlencoded for everything that
+        # is not multipart and take the fast path (also: 3.1 workaround)
+        if not self.content_type.startswith('multipart/'):
+            maxlen = max(0, min(self.content_length, self.MEMFILE_MAX))
+            pairs = _parse_qsl(tonat(self.body.read(maxlen), 'latin1'))
+            for key, value in pairs[:self.MAX_PARAMS]:
+                post[key] = value
+            return post
+
         safe_env = {'QUERY_STRING':''} # Build a safe environment for cgi
         for key in ('REQUEST_METHOD', 'CONTENT_TYPE', 'CONTENT_LENGTH'):
             if key in self.environ: safe_env[key] = self.environ[key]
-        if NCTextIOWrapper:
-            fb = NCTextIOWrapper(self.body, encoding='ISO-8859-1', newline='\n')
-        else:
-            fb = self.body
-        data = cgi.FieldStorage(fp=fb, environ=safe_env, keep_blank_values=True)
-        for item in data.list or []:
+        args = dict(fp=self.body, environ=safe_env, keep_blank_values=True)
+        if py31:
+            args['fp'] = NCTextIOWrapper(args['fp'], encoding='ISO-8859-1',
+                                         newline='\n')
+        elif py3k:
+            args['encoding'] = 'ISO-8859-1'
+        data = FieldStorage(**args)
+        for item in (data.list or [])[:self.MAX_PARAMS]:
             post[item.name] = item if item.filename else item.value
         return post
 
@@ -1042,7 +1095,7 @@ class BaseRequest(DictMixin):
             but the fragment is always empty because it is not visible to the
             server. '''
         env = self.environ
-        http = env.get('wsgi.url_scheme', 'http')
+        http = env.get('HTTP_X_FORWARDED_PROTO') or env.get('wsgi.url_scheme', 'http')
         host = env.get('HTTP_X_FORWARDED_HOST') or env.get('HTTP_HOST')
         if not host:
             # HTTP 1.1 requires a Host-header. This is for HTTP/1.0 clients.
@@ -1091,6 +1144,11 @@ class BaseRequest(DictMixin):
         return int(self.environ.get('CONTENT_LENGTH') or -1)
 
     @property
+    def content_type(self):
+        ''' The Content-Type header as a lowercase-string (default: empty). '''
+        return self.environ.get('CONTENT_TYPE', '').lower()
+
+    @property
     def is_xhr(self):
         ''' True if the request was triggered by a XMLHttpRequest. This only
             works with JavaScript libraries that support the `X-Requested-With`
@@ -1139,6 +1197,7 @@ class BaseRequest(DictMixin):
         """ Return a new :class:`Request` with a shallow :attr:`environ` copy. """
         return Request(self.environ.copy())
 
+    def get(self, value, default=None): return self.environ.get(value, default)
     def __getitem__(self, key): return self.environ[key]
     def __delitem__(self, key): self[key] = ""; del(self.environ[key])
     def __iter__(self): return iter(self.environ)
@@ -1166,27 +1225,41 @@ class BaseRequest(DictMixin):
     def __repr__(self):
         return '<%s: %s %s>' % (self.__class__.__name__, self.method, self.url)
 
+    def __getattr__(self, name):
+        ''' Search in self.environ for additional user defined attributes. '''
+        try:
+            var = self.environ['bottle.request.ext.%s'%name]
+            return var.__get__(self) if hasattr(var, '__get__') else var
+        except KeyError:
+            raise AttributeError('Attribute %r not defined.' % name)
+
+    def __setattr__(self, name, value):
+        if name == 'environ': return object.__setattr__(self, name, value)
+        self.environ['bottle.request.ext.%s'%name] = value
+
+
+
+
 def _hkey(s):
     return s.title().replace('_','-')
 
 
 class HeaderProperty(object):
     def __init__(self, name, reader=None, writer=str, default=''):
-        self.name, self.reader, self.writer, self.default = name, reader, writer, default
+        self.name, self.default = name, default
+        self.reader, self.writer = reader, writer
         self.__doc__ = 'Current value of the %r header.' % name.title()
 
     def __get__(self, obj, cls):
         if obj is None: return self
-        value = obj.headers.get(self.name)
-        return self.reader(value) if (value and self.reader) else (value or self.default)
+        value = obj.headers.get(self.name, self.default)
+        return self.reader(value) if self.reader else value
 
     def __set__(self, obj, value):
-        if self.writer: value = self.writer(value)
-        obj.headers[self.name] = value
+        obj.headers[self.name] = self.writer(value)
 
     def __delete__(self, obj):
-        if self.name in obj.headers:
-            del obj.headers[self.name]
+        del obj.headers[self.name]
 
 
 class BaseResponse(object):
@@ -1209,11 +1282,9 @@ class BaseResponse(object):
                   'Content-Md5', 'Last-Modified'))}
 
     def __init__(self, body='', status=None, **headers):
-        self._status_line = None
-        self._status_code = None
-        self.body = body
         self._cookies = None
         self._headers = {'Content-Type': [self.default_content_type]}
+        self.body = body
         self.status = status or self.default_status
         if headers:
             for name, value in headers.items():
@@ -1253,26 +1324,24 @@ class BaseResponse(object):
             raise ValueError('String status line without a reason phrase.')
         if not 100 <= code <= 999: raise ValueError('Status code out of range.')
         self._status_code = code
-        self._status_line = status or ('%d Unknown' % code)
+        self._status_line = str(status or ('%d Unknown' % code))
 
     def _get_status(self):
-        depr('BaseReuqest.status will change to return a string in 0.11. Use'\
-             ' status_line and status_code to make sure.') #0.10
-        return self._status_code
+        return self._status_line
 
     status = property(_get_status, _set_status, None,
         ''' A writeable property to change the HTTP response status. It accepts
             either a numeric code (100-999) or a string with a custom reason
             phrase (e.g. "404 Brain not found"). Both :data:`status_line` and
-            :data:`status_code` are updates accordingly. The return value is
-            always a numeric code. ''')
+            :data:`status_code` are updated accordingly. The return value is
+            always a status string. ''')
     del _get_status, _set_status
 
     @property
     def headers(self):
         ''' An instance of :class:`HeaderDict`, a case-insensitive dict-like
             view on the response headers. '''
-        self.__dict__['headers'] = hdict = HeaderDict()
+        hdict = HeaderDict()
         hdict.dict = self._headers
         return hdict
 
@@ -1286,13 +1355,10 @@ class BaseResponse(object):
             header with that name, return a default value. '''
         return self._headers.get(_hkey(name), [default])[-1]
 
-    def set_header(self, name, value, append=False):
+    def set_header(self, name, value):
         ''' Create a new response header, replacing any previously defined
             headers with the same name. '''
-        if append:
-            self.add_header(name, value)
-        else:
-            self._headers[_hkey(name)] = [str(value)]
+        self._headers[_hkey(name)] = [str(value)]
 
     def add_header(self, name, value):
         ''' Add an additional response header, not removing duplicates. '''
@@ -1301,16 +1367,7 @@ class BaseResponse(object):
     def iter_headers(self):
         ''' Yield (header, value) tuples, skipping headers that are not
             allowed with the current response status code. '''
-        headers = self._headers.iteritems()
-        bad_headers = self.bad_headers.get(self.status_code)
-        if bad_headers:
-            headers = [h for h in headers if h[0] not in bad_headers]
-        for name, values in headers:
-            for value in values:
-                yield name, value
-        if self._cookies:
-            for c in self._cookies.values():
-                yield 'Set-Cookie', c.OutputString()
+        return self.headerlist
 
     def wsgiheader(self):
         depr('The wsgiheader method is deprecated. See headerlist.') #0.10
@@ -1319,7 +1376,16 @@ class BaseResponse(object):
     @property
     def headerlist(self):
         ''' WSGI conform list of (header, value) tuples. '''
-        return list(self.iter_headers())
+        out = []
+        headers = self._headers.items()
+        if self._status_code in self.bad_headers:
+            bad_headers = self.bad_headers[self._status_code]
+            headers = [h for h in headers if h[0] not in bad_headers]
+        out += [(name, val) for name, vals in headers for val in vals]
+        if self._cookies:
+            for c in self._cookies.values():
+                out.append(('Set-Cookie', c.OutputString()))
+        return out
 
     content_type = HeaderProperty('Content-Type')
     content_length = HeaderProperty('Content-Length', reader=int)
@@ -1384,7 +1450,7 @@ class BaseResponse(object):
         if len(value) > 4096: raise ValueError('Cookie value to long.')
         self._cookies[name] = value
 
-        for key, value in options.iteritems():
+        for key, value in options.items():
             if key == 'max_age':
                 if isinstance(value, timedelta):
                     value = value.seconds + value.days * 24 * 3600
@@ -1409,20 +1475,76 @@ class BaseResponse(object):
             out += '%s: %s\n' % (name.title(), value.strip())
         return out
 
+#: Thread-local storage for :class:`LocalRequest` and :class:`LocalResponse`
+#: attributes.
+_lctx = threading.local()
 
-class LocalRequest(BaseRequest, threading.local):
-    ''' A thread-local subclass of :class:`BaseRequest`. '''
-    def __init__(self): pass
+def local_property(name):
+    def fget(self):
+        try:
+            return getattr(_lctx, name)
+        except AttributeError:
+            raise RuntimeError("Request context not initialized.")
+    def fset(self, value): setattr(_lctx, name, value)
+    def fdel(self): delattr(_lctx, name)
+    return property(fget, fset, fdel,
+        'Thread-local property stored in :data:`_lctx.%s`' % name)
+
+
+class LocalRequest(BaseRequest):
+    ''' A thread-local subclass of :class:`BaseRequest` with a different
+        set of attribues for each thread. There is usually only one global
+        instance of this class (:data:`request`). If accessed during a
+        request/response cycle, this instance always refers to the *current*
+        request (even on a multithreaded server). '''
     bind = BaseRequest.__init__
+    environ = local_property('request_environ')
 
 
-class LocalResponse(BaseResponse, threading.local):
-    ''' A thread-local subclass of :class:`BaseResponse`. '''
+class LocalResponse(BaseResponse):
+    ''' A thread-local subclass of :class:`BaseResponse` with a different
+        set of attribues for each thread. There is usually only one global
+        instance of this class (:data:`response`). Its attributes are used
+        to build the HTTP response at the end of the request/response cycle.
+    '''
     bind = BaseResponse.__init__
+    _status_line = local_property('response_status_line')
+    _status_code = local_property('response_status_code')
+    _cookies     = local_property('response_cookies')
+    _headers     = local_property('response_headers')
+    body         = local_property('response_body')
+
+Request = BaseRequest
+Response = BaseResponse
+
+class HTTPResponse(Response, BottleException):
+    def __init__(self, body='', status=None, header=None, **headers):
+        if header or 'output' in headers:
+            depr('Call signature changed (for the better)')
+            if header: headers.update(header)
+            if 'output' in headers: body = headers.pop('output')
+        super(HTTPResponse, self).__init__(body, status, **headers)
+
+    def apply(self, response):
+        response._status_code = self._status_code
+        response._status_line = self._status_line
+        response._headers = self._headers
+        response._cookies = self._cookies
+        response.body = self.body
 
-Response = LocalResponse # BC 0.9
-Request  = LocalRequest  # BC 0.9
+    def _output(self, value=None):
+        depr('Use HTTPResponse.body instead of HTTPResponse.output')
+        if value is None: return self.body
+        self.body = value
 
+    output = property(_output, _output, doc='Alias for .body')
+
+class HTTPError(HTTPResponse):
+    default_status = 500
+    def __init__(self, status=None, body=None, exception=None, traceback=None, header=None, **headers):
+        self.exception = exception
+        self.traceback = traceback
+        super(HTTPError, self).__init__(body, status, header, **headers)
 
 
 
@@ -1441,7 +1563,7 @@ class JSONPlugin(object):
     def __init__(self, json_dumps=json_dumps):
         self.json_dumps = json_dumps
 
-    def apply(self, callback, context):
+    def apply(self, callback, route):
         dumps = self.json_dumps
         if not dumps: return callback
         def wrapper(*a, **ka):
@@ -1491,7 +1613,7 @@ class HooksPlugin(object):
         if ka.pop('reversed', False): hooks = hooks[::-1]
         return [hook(*a, **ka) for hook in hooks]
 
-    def apply(self, callback, context):
+    def apply(self, callback, route):
         if self._empty(): return callback
         def wrapper(*a, **ka):
             self.trigger('before_request')
@@ -1566,26 +1688,37 @@ class MultiDict(DictMixin):
     """
 
     def __init__(self, *a, **k):
-        self.dict = dict((k, [v]) for k, v in dict(*a, **k).iteritems())
+        self.dict = dict((k, [v]) for (k, v) in dict(*a, **k).items())
+
     def __len__(self): return len(self.dict)
     def __iter__(self): return iter(self.dict)
     def __contains__(self, key): return key in self.dict
     def __delitem__(self, key): del self.dict[key]
     def __getitem__(self, key): return self.dict[key][-1]
     def __setitem__(self, key, value): self.append(key, value)
-    def iterkeys(self): return self.dict.iterkeys()
-    def itervalues(self): return (v[-1] for v in self.dict.itervalues())
-    def iteritems(self): return ((k, v[-1]) for (k, v) in self.dict.iteritems())
-    def iterallitems(self):
-        for key, values in self.dict.iteritems():
-            for value in values:
-                yield key, value
-
-    # 2to3 is not able to fix these automatically.
-    keys     = iterkeys     if py3k else lambda self: list(self.iterkeys())
-    values   = itervalues   if py3k else lambda self: list(self.itervalues())
-    items    = iteritems    if py3k else lambda self: list(self.iteritems())
-    allitems = iterallitems if py3k else lambda self: list(self.iterallitems())
+    def keys(self): return self.dict.keys()
+
+    if py3k:
+        def values(self): return (v[-1] for v in self.dict.values())
+        def items(self): return ((k, v[-1]) for k, v in self.dict.items())
+        def allitems(self):
+            return ((k, v) for k, vl in self.dict.items() for v in vl)
+        iterkeys = keys
+        itervalues = values
+        iteritems = items
+        iterallitems = allitems
+
+    else:
+        def values(self): return [v[-1] for v in self.dict.values()]
+        def items(self): return [(k, v[-1]) for k, v in self.dict.items()]
+        def iterkeys(self): return self.dict.iterkeys()
+        def itervalues(self): return (v[-1] for v in self.dict.itervalues())
+        def iteritems(self):
+            return ((k, v[-1]) for k, v in self.dict.iteritems())
+        def iterallitems(self):
+            return ((k, v) for k, vl in self.dict.iteritems() for v in vl)
+        def allitems(self):
+            return [(k, v) for k, vl in self.dict.iteritems() for v in vl]
 
     def get(self, key, default=None, index=-1, type=None):
         ''' Return the most recent value for a key.
@@ -1600,7 +1733,7 @@ class MultiDict(DictMixin):
         try:
             val = self.dict[key][index]
             return type(val) if type else val
-        except Exception, e:
+        except Exception:
             pass
         return default
 
@@ -1626,25 +1759,45 @@ class FormsDict(MultiDict):
     ''' This :class:`MultiDict` subclass is used to store request form data.
         Additionally to the normal dict-like item access methods (which return
         unmodified data as native strings), this container also supports
-        attribute-like access to its values. Attribues are automatiically de- or
-        recoded to match :attr:`input_encoding` (default: 'utf8'). Missing
+        attribute-like access to its values. Attributes are automatically de-
+        or recoded to match :attr:`input_encoding` (default: 'utf8'). Missing
         attributes default to an empty string. '''
 
     #: Encoding used for attribute values.
     input_encoding = 'utf8'
+    #: If true (default), unicode strings are first encoded with `latin1`
+    #: and then decoded to match :attr:`input_encoding`.
+    recode_unicode = True
+
+    def _fix(self, s, encoding=None):
+        if isinstance(s, unicode) and self.recode_unicode: # Python 3 WSGI
+            s = s.encode('latin1')
+        if isinstance(s, bytes): # Python 2 WSGI
+            return s.decode(encoding or self.input_encoding)
+        return s
+
+    def decode(self, encoding=None):
+        ''' Returns a copy with all keys and values de- or recoded to match
+            :attr:`input_encoding`. Some libraries (e.g. WTForms) want a
+            unicode dictionary. '''
+        copy = FormsDict()
+        enc = copy.input_encoding = encoding or self.input_encoding
+        copy.recode_unicode = False
+        for key, value in self.allitems():
+            copy.append(self._fix(key, enc), self._fix(value, enc))
+        return copy
 
     def getunicode(self, name, default=None, encoding=None):
-        value, enc = self.get(name, default), encoding or self.input_encoding
         try:
-            if isinstance(value, bytes): # Python 2 WSGI
-                return value.decode(enc)
-            elif isinstance(value, unicode): # Python 3 WSGI
-                return value.encode('latin1').decode(enc)
-            return value
-        except UnicodeError, e:
+            return self._fix(self[name], encoding)
+        except (UnicodeError, KeyError):
             return default
 
-    def __getattr__(self, name): return self.getunicode(name, default=u'')
+    def __getattr__(self, name, default=unicode()):
+        # Without this guard, pickle generates a cryptic TypeError:
+        if name.startswith('__') and name.endswith('__'):
+            return super(FormsDict, self).__getattr__(name)
+        return self.getunicode(name, default=default)
 
 
 class HeaderDict(MultiDict):
@@ -1666,7 +1819,7 @@ class HeaderDict(MultiDict):
     def get(self, key, default=None, index=-1):
         return MultiDict.get(self, _hkey(key), default, index)
     def filter(self, names):
-        for name in map(_hkey, names):
+        for name in [_hkey(n) for n in names]:
             if name in self.dict:
                 del self.dict[name]
 
@@ -1682,7 +1835,7 @@ class WSGIHeaderDict(DictMixin):
         Currently PEP 333, 444 and 3333 are supported. (PEP 444 is the only one
         that uses non-native strings.)
     '''
-    #: List of keys that do not have a 'HTTP_' prefix.
+    #: List of keys that do not have a ``HTTP_`` prefix.
     cgikeys = ('CONTENT_TYPE', 'CONTENT_LENGTH')
 
     def __init__(self, environ):
@@ -1749,7 +1902,7 @@ class ConfigDict(dict):
         if key in self: del self[key]
 
     def __call__(self, *a, **ka):
-        for key, value in dict(*a, **ka).iteritems(): setattr(self, key, value)
+        for key, value in dict(*a, **ka).items(): setattr(self, key, value)
         return self
 
 
@@ -1770,17 +1923,103 @@ class AppStack(list):
 
 class WSGIFileWrapper(object):
 
-   def __init__(self, fp, buffer_size=1024*64):
-       self.fp, self.buffer_size = fp, buffer_size
-       for attr in ('fileno', 'close', 'read', 'readlines'):
-           if hasattr(fp, attr): setattr(self, attr, getattr(fp, attr))
+    def __init__(self, fp, buffer_size=1024*64):
+        self.fp, self.buffer_size = fp, buffer_size
+        for attr in ('fileno', 'close', 'read', 'readlines', 'tell', 'seek'):
+            if hasattr(fp, attr): setattr(self, attr, getattr(fp, attr))
+
+    def __iter__(self):
+        buff, read = self.buffer_size, self.read
+        while True:
+            part = read(buff)
+            if not part: return
+            yield part
+
+
+class ResourceManager(object):
+    ''' This class manages a list of search paths and helps to find and open
+        application-bound resources (files).
+
+        :param base: default value for :meth:`add_path` calls.
+        :param opener: callable used to open resources.
+        :param cachemode: controls which lookups are cached. One of 'all',
+                         'found' or 'none'.
+    '''
+
+    def __init__(self, base='./', opener=open, cachemode='all'):
+        self.opener = open
+        self.base = base
+        self.cachemode = cachemode
 
-   def __iter__(self):
-       read, buff = self.fp.read, self.buffer_size
-       while True:
-           part = read(buff)
-           if not part: break
-           yield part
+        #: A list of search paths. See :meth:`add_path` for details.
+        self.path = []
+        #: A cache for resolved paths. ``res.cache.clear()`` clears the cache.
+        self.cache = {}
+
+    def add_path(self, path, base=None, index=None, create=False):
+        ''' Add a new path to the list of search paths. Return False if the
+            path does not exist.
+
+            :param path: The new search path. Relative paths are turned into
+                an absolute and normalized form. If the path looks like a file
+                (not ending in `/`), the filename is stripped off.
+            :param base: Path used to absolutize relative search paths.
+                Defaults to :attr:`base` which defaults to ``os.getcwd()``.
+            :param index: Position within the list of search paths. Defaults
+                to last index (appends to the list).
+
+            The `base` parameter makes it easy to reference files installed
+            along with a python module or package::
+
+                res.add_path('./resources/', __file__)
+        '''
+        base = os.path.abspath(os.path.dirname(base or self.base))
+        path = os.path.abspath(os.path.join(base, os.path.dirname(path)))
+        path += os.sep
+        if path in self.path:
+            self.path.remove(path)
+        if create and not os.path.isdir(path):
+            os.makedirs(path)
+        if index is None:
+            self.path.append(path)
+        else:
+            self.path.insert(index, path)
+        self.cache.clear()
+        return os.path.exists(path)
+
+    def __iter__(self):
+        ''' Iterate over all existing files in all registered paths. '''
+        search = self.path[:]
+        while search:
+            path = search.pop()
+            if not os.path.isdir(path): continue
+            for name in os.listdir(path):
+                full = os.path.join(path, name)
+                if os.path.isdir(full): search.append(full)
+                else: yield full
+
+    def lookup(self, name):
+        ''' Search for a resource and return an absolute file path, or `None`.
+
+            The :attr:`path` list is searched in order. The first match is
+            returend. Symlinks are followed. The result is cached to speed up
+            future lookups. '''
+        if name not in self.cache or DEBUG:
+            for path in self.path:
+                fpath = os.path.join(path, name)
+                if os.path.isfile(fpath):
+                    if self.cachemode in ('all', 'found'):
+                        self.cache[name] = fpath
+                    return fpath
+            if self.cachemode == 'all':
+                self.cache[name] = None
+        return self.cache[name]
+
+    def open(self, name, mode='r', *args, **kwargs):
+        ''' Find a resource and return a file object, or raise IOError. '''
+        fname = self.lookup(name)
+        if not fname: raise IOError("Resource %r not found." % name)
+        return self.opener(name, mode=mode, *args, **kwargs)
 
 
 
@@ -1803,7 +2042,20 @@ def redirect(url, code=None):
     if code is None:
         code = 303 if request.get('SERVER_PROTOCOL') == "HTTP/1.1" else 302
     location = urljoin(request.url, url)
-    raise HTTPResponse("", status=code, header=dict(Location=location))
+    res = HTTPResponse("", status=code, Location=location)
+    if response._cookies:
+        res._cookies = response._cookies
+    raise res
+
+
+def _file_iter_range(fp, offset, bytes, maxread=1024*1024):
+    ''' Yield chunks from a range in a file. No chunk is bigger than maxread.'''
+    fp.seek(offset)
+    while bytes > 0:
+        part = fp.read(min(bytes, maxread))
+        if not part: break
+        bytes -= len(part)
+        yield part
 
 
 def static_file(filename, root, mimetype='auto', download=False):
@@ -1814,7 +2066,7 @@ def static_file(filename, root, mimetype='auto', download=False):
     """
     root = os.path.abspath(root) + os.sep
     filename = os.path.abspath(os.path.join(root, filename.strip('/\\')))
-    header = dict()
+    headers = dict()
 
     if not filename.startswith(root):
         return HTTPError(403, "Access denied.")
@@ -1825,29 +2077,41 @@ def static_file(filename, root, mimetype='auto', download=False):
 
     if mimetype == 'auto':
         mimetype, encoding = mimetypes.guess_type(filename)
-        if mimetype: header['Content-Type'] = mimetype
-        if encoding: header['Content-Encoding'] = encoding
+        if mimetype: headers['Content-Type'] = mimetype
+        if encoding: headers['Content-Encoding'] = encoding
     elif mimetype:
-        header['Content-Type'] = mimetype
+        headers['Content-Type'] = mimetype
 
     if download:
         download = os.path.basename(filename if download == True else download)
-        header['Content-Disposition'] = 'attachment; filename="%s"' % download
+        headers['Content-Disposition'] = 'attachment; filename="%s"' % download
 
     stats = os.stat(filename)
-    header['Content-Length'] = stats.st_size
+    headers['Content-Length'] = clen = stats.st_size
     lm = time.strftime("%a, %d %b %Y %H:%M:%S GMT", time.gmtime(stats.st_mtime))
-    header['Last-Modified'] = lm
+    headers['Last-Modified'] = lm
 
     ims = request.environ.get('HTTP_IF_MODIFIED_SINCE')
     if ims:
         ims = parse_date(ims.split(";")[0].strip())
     if ims is not None and ims >= int(stats.st_mtime):
-        header['Date'] = time.strftime("%a, %d %b %Y %H:%M:%S GMT", time.gmtime())
-        return HTTPResponse(status=304, header=header)
+        headers['Date'] = time.strftime("%a, %d %b %Y %H:%M:%S GMT", time.gmtime())
+        return HTTPResponse(status=304, **headers)
 
     body = '' if request.method == 'HEAD' else open(filename, 'rb')
-    return HTTPResponse(body, header=header)
+
+    headers["Accept-Ranges"] = "bytes"
+    ranges = request.environ.get('HTTP_RANGE')
+    if 'HTTP_RANGE' in request.environ:
+        ranges = list(parse_range_header(request.environ['HTTP_RANGE'], clen))
+        if not ranges:
+            return HTTPError(416, "Requested Range Not Satisfiable")
+        offset, end = ranges[0]
+        headers["Content-Range"] = "bytes %d-%d/%d" % (offset, end-1, clen)
+        headers["Content-Length"] = str(end-offset)
+        if body: body = _file_iter_range(body, offset, end-offset)
+        return HTTPResponse(body, status=206, **headers)
+    return HTTPResponse(body, **headers)
 
 
 
@@ -1880,15 +2144,42 @@ def parse_auth(header):
     try:
         method, data = header.split(None, 1)
         if method.lower() == 'basic':
-            #TODO: Add 2to3 save base64[encode/decode] functions.
             user, pwd = touni(base64.b64decode(tob(data))).split(':',1)
             return user, pwd
     except (KeyError, ValueError):
         return None
 
+def parse_range_header(header, maxlen=0):
+    ''' Yield (start, end) ranges parsed from a HTTP Range header. Skip
+        unsatisfiable ranges. The end index is non-inclusive.'''
+    if not header or header[:6] != 'bytes=': return
+    ranges = [r.split('-', 1) for r in header[6:].split(',') if '-' in r]
+    for start, end in ranges:
+        try:
+            if not start:  # bytes=-100    -> last 100 bytes
+                start, end = max(0, maxlen-int(end)), maxlen
+            elif not end:  # bytes=100-    -> all but the first 99 bytes
+                start, end = int(start), maxlen
+            else:          # bytes=100-200 -> bytes 100-200 (inclusive)
+                start, end = int(start), min(int(end)+1, maxlen)
+            if 0 <= start < end <= maxlen:
+                yield start, end
+        except ValueError:
+            pass
+
+def _parse_qsl(qs):
+    r = []
+    for pair in qs.replace(';','&').split('&'):
+        if not pair: continue
+        nv = pair.split('=', 1)
+        if len(nv) != 2: nv.append('')
+        key = urlunquote(nv[0].replace('+', ' '))
+        value = urlunquote(nv[1].replace('+', ' '))
+        r.append((key, value))
+    return r
 
 def _lscmp(a, b):
-    ''' Compares two strings in a cryptographically save way:
+    ''' Compares two strings in a cryptographically safe way:
         Runtime is not affected by length of common prefix. '''
     return not sum(0 if x==y else 1 for x, y in zip(a, b)) and len(a) == len(b)
 
@@ -1988,7 +2279,7 @@ def validate(**vkargs):
     def decorator(func):
         @functools.wraps(func)
         def wrapper(*args, **kargs):
-            for key, value in vkargs.iteritems():
+            for key, value in vkargs.items():
                 if key not in kargs:
                     abort(403, 'Missing parameter: %s' % key)
                 try:
@@ -2014,6 +2305,9 @@ def auth_basic(check, realm="private", text="Access denied"):
     return decorator
 
 
+# Shortcuts for common Bottle methods.
+# They all refer to the current default application.
+
 def make_default_app_wrapper(name):
     ''' Return a callable that relays calls to the current default app. '''
     @functools.wraps(getattr(Bottle, name))
@@ -2021,12 +2315,18 @@ def make_default_app_wrapper(name):
         return getattr(app(), name)(*a, **ka)
     return wrapper
 
+route     = make_default_app_wrapper('route')
+get       = make_default_app_wrapper('get')
+post      = make_default_app_wrapper('post')
+put       = make_default_app_wrapper('put')
+delete    = make_default_app_wrapper('delete')
+error     = make_default_app_wrapper('error')
+mount     = make_default_app_wrapper('mount')
+hook      = make_default_app_wrapper('hook')
+install   = make_default_app_wrapper('install')
+uninstall = make_default_app_wrapper('uninstall')
+url       = make_default_app_wrapper('get_url')
 
-for name in '''route get post put delete error mount
-               hook install uninstall'''.split():
-    globals()[name] = make_default_app_wrapper(name)
-url = make_default_app_wrapper('get_url')
-del name
 
 
 
@@ -2091,6 +2391,12 @@ class CherryPyServer(ServerAdapter):
             server.stop()
 
 
+class WaitressServer(ServerAdapter):
+    def run(self, handler):
+        from waitress import serve
+        serve(handler, host=self.host, port=self.port)
+
+
 class PasteServer(ServerAdapter):
     def run(self, handler): # pragma: no cover
         from paste import httpserver
@@ -2120,8 +2426,8 @@ class FapwsServer(ServerAdapter):
         evwsgi.start(self.host, port)
         # fapws3 never releases the GIL. Complain upstream. I tried. No luck.
         if 'BOTTLE_CHILD' in os.environ and not self.quiet:
-            print "WARNING: Auto-reloading does not work with Fapws3."
-            print "         (Fapws3 breaks python thread support)"
+            _stderr("WARNING: Auto-reloading does not work with Fapws3.\n")
+            _stderr("         (Fapws3 breaks python thread support)\n")
         evwsgi.set_base_module(base)
         def app(environ, start_response):
             environ['wsgi.multiprocess'] = False
@@ -2178,16 +2484,17 @@ class DieselServer(ServerAdapter):
 class GeventServer(ServerAdapter):
     """ Untested. Options:
 
-        * `monkey` (default: True) fixes the stdlib to use greenthreads.
         * `fast` (default: False) uses libevent's http server, but has some
           issues: No streaming, no pipelining, no SSL.
     """
     def run(self, handler):
-        from gevent import wsgi as wsgi_fast, pywsgi, monkey, local
-        if self.options.get('monkey', True):
-            if not threading.local is local.local: monkey.patch_all()
-        wsgi = wsgi_fast if self.options.get('fast') else pywsgi
-        wsgi.WSGIServer((self.host, self.port), handler).serve_forever()
+        from gevent import wsgi, pywsgi, local
+        if not isinstance(_lctx, local.local):
+            msg = "Bottle requires gevent.monkey.patch_all() (before import)"
+            raise RuntimeError(msg)
+        if not self.options.get('fast'): wsgi = pywsgi
+        log = None if self.quiet else 'default'
+        wsgi.WSGIServer((self.host, self.port), handler, log=log).serve_forever()
 
 
 class GunicornServer(ServerAdapter):
@@ -2212,7 +2519,12 @@ class EventletServer(ServerAdapter):
     """ Untested """
     def run(self, handler):
         from eventlet import wsgi, listen
-        wsgi.server(listen((self.host, self.port)), handler)
+        try:
+            wsgi.server(listen((self.host, self.port)), handler,
+                        log_output=(not self.quiet))
+        except TypeError:
+            # Fallback, if we have old version of eventlet
+            wsgi.server(listen((self.host, self.port)), handler)
 
 
 class RocketServer(ServerAdapter):
@@ -2232,7 +2544,7 @@ class BjoernServer(ServerAdapter):
 
 class AutoServer(ServerAdapter):
     """ Untested. """
-    adapters = [PasteServer, CherryPyServer, TwistedServer, WSGIRefServer]
+    adapters = [WaitressServer, PasteServer, TwistedServer, CherryPyServer, WSGIRefServer]
     def run(self, handler):
         for sa in self.adapters:
             try:
@@ -2244,6 +2556,7 @@ server_names = {
     'cgi': CGIServer,
     'flup': FlupFCGIServer,
     'wsgiref': WSGIRefServer,
+    'waitress': WaitressServer,
     'cherrypy': CherryPyServer,
     'paste': PasteServer,
     'fapws3': FapwsServer,
@@ -2303,8 +2616,10 @@ def load_app(target):
         default_app.remove(tmp) # Remove the temporary added default application
         NORUN = nr_old
 
+_debug = debug
 def run(app=None, server='wsgiref', host='127.0.0.1', port=8080,
-        interval=1, reloader=False, quiet=False, plugins=None, **kargs):
+        interval=1, reloader=False, quiet=False, plugins=None,
+        debug=False, **kargs):
     """ Start a server instance. This method blocks until the server terminates.
 
         :param app: WSGI application or target string supported by
@@ -2324,6 +2639,7 @@ def run(app=None, server='wsgiref', host='127.0.0.1', port=8080,
     if NORUN: return
     if reloader and not os.environ.get('BOTTLE_CHILD'):
         try:
+            lockfile = None
             fd, lockfile = tempfile.mkstemp(prefix='bottle.', suffix='.lock')
             os.close(fd) # We only need this file to exist. We never write to it
             while os.path.exists(lockfile):
@@ -2345,9 +2661,8 @@ def run(app=None, server='wsgiref', host='127.0.0.1', port=8080,
                 os.unlink(lockfile)
         return
 
-    stderr = sys.stderr.write
-
     try:
+        _debug(debug)
         app = app or default_app()
         if isinstance(app, basestring):
             app = load_app(app)
@@ -2368,9 +2683,9 @@ def run(app=None, server='wsgiref', host='127.0.0.1', port=8080,
 
         server.quiet = server.quiet or quiet
         if not server.quiet:
-            stderr("Bottle server starting up (using %s)...\n" % repr(server))
-            stderr("Listening on http://%s:%d/\n" % (server.host, server.port))
-            stderr("Hit Ctrl-C to quit.\n\n")
+            _stderr("Bottle v%s server starting up (using %s)...\n" % (__version__, repr(server)))
+            _stderr("Listening on http://%s:%d/\n" % (server.host, server.port))
+            _stderr("Hit Ctrl-C to quit.\n\n")
 
         if reloader:
             lockfile = os.environ.get('BOTTLE_LOCKFILE')
@@ -2383,12 +2698,15 @@ def run(app=None, server='wsgiref', host='127.0.0.1', port=8080,
             server.run(app)
     except KeyboardInterrupt:
         pass
-    except (SyntaxError, ImportError):
+    except (SystemExit, MemoryError):
+        raise
+    except:
         if not reloader: raise
-        if not getattr(server, 'quiet', False): print_exc()
+        if not getattr(server, 'quiet', quiet):
+            print_exc()
+        time.sleep(interval)
         sys.exit(3)
-    finally:
-        if not getattr(server, 'quiet', False): stderr('Shutdown...\n')
+
 
 
 class FileCheckerThread(threading.Thread):
@@ -2406,7 +2724,7 @@ class FileCheckerThread(threading.Thread):
         mtime = lambda path: os.stat(path).st_mtime
         files = dict()
 
-        for module in sys.modules.values():
+        for module in list(sys.modules.values()):
             path = getattr(module, '__file__', '')
             if path[-4:] in ('.pyo', '.pyc'): path = path[:-1]
             if path and exists(path): files[path] = mtime(path)
@@ -2416,20 +2734,20 @@ class FileCheckerThread(threading.Thread):
             or mtime(self.lockfile) < time.time() - self.interval - 5:
                 self.status = 'error'
                 thread.interrupt_main()
-            for path, lmtime in files.iteritems():
+            for path, lmtime in list(files.items()):
                 if not exists(path) or mtime(path) > lmtime:
                     self.status = 'reload'
                     thread.interrupt_main()
                     break
             time.sleep(self.interval)
-    
+
     def __enter__(self):
         self.start()
-    
+
     def __exit__(self, exc_type, exc_val, exc_tb):
         if not self.status: self.status = 'exit' # silent exit
         self.join()
-        return issubclass(exc_type, KeyboardInterrupt)
+        return exc_type is not None and issubclass(exc_type, KeyboardInterrupt)
 
 
 
@@ -2465,7 +2783,7 @@ class BaseTemplate(object):
         self.name = name
         self.source = source.read() if hasattr(source, 'read') else source
         self.filename = source.filename if hasattr(source, 'filename') else None
-        self.lookup = map(os.path.abspath, lookup)
+        self.lookup = [os.path.abspath(x) for x in lookup]
         self.encoding = encoding
         self.settings = self.settings.copy() # Copy from class variable
         self.settings.update(settings) # Apply
@@ -2481,11 +2799,19 @@ class BaseTemplate(object):
     def search(cls, name, lookup=[]):
         """ Search name in all directories specified in lookup.
         First without, then with common extensions. Return first hit. """
-        if os.path.isfile(name): return name
+        if not lookup:
+            depr('The template lookup path list should not be empty.')
+            lookup = ['.']
+
+        if os.path.isabs(name) and os.path.isfile(name):
+            depr('Absolute template path names are deprecated.')
+            return os.path.abspath(name)
+
         for spath in lookup:
-            fname = os.path.join(spath, name)
-            if os.path.isfile(fname):
-                return fname
+            spath = os.path.abspath(spath) + os.sep
+            fname = os.path.abspath(os.path.join(spath, name))
+            if not fname.startswith(spath): continue
+            if os.path.isfile(fname): return fname
             for ext in cls.extensions:
                 if os.path.isfile('%s.%s' % (fname, ext)):
                     return '%s.%s' % (fname, ext)
@@ -2577,16 +2903,17 @@ class Jinja2Template(BaseTemplate):
 
     def loader(self, name):
         fname = self.search(name, self.lookup)
-        if fname:
-            with open(fname, "rb") as f:
-                return f.read().decode(self.encoding)
+        if not fname: return
+        with open(fname, "rb") as f:
+            return f.read().decode(self.encoding)
 
 
 class SimpleTALTemplate(BaseTemplate):
-    ''' Untested! '''
+    ''' Deprecated, do not use. '''
     def prepare(self, **options):
+        depr('The SimpleTAL template handler is deprecated'\
+             ' and will be removed in 0.12')
         from simpletal import simpleTAL
-        # TODO: add option to load METAL files during render
         if self.source:
             self.tpl = simpleTAL.compileHTMLTemplate(self.source)
         else:
@@ -2596,7 +2923,6 @@ class SimpleTALTemplate(BaseTemplate):
     def render(self, *args, **kwargs):
         from simpletal import simpleTALES
         for dictarg in args: kwargs.update(dictarg)
-        # TODO: maybe reuse a context instead of always creating one
         context = simpleTALES.Context()
         for k,v in self.defaults.items():
             context.addGlobal(k, v)
@@ -2684,13 +3010,13 @@ class SimpleTemplate(BaseTemplate):
 
         for line in template.splitlines(True):
             lineno += 1
-            line = line if isinstance(line, unicode)\
-                        else unicode(line, encoding=self.encoding)
+            line = touni(line, self.encoding)
+            sline = line.lstrip()
             if lineno <= 2:
-                m = re.search(r"%.*coding[:=]\s*([-\w\.]+)", line)
+                m = re.match(r"%\s*#.*coding[:=]\s*([-\w.]+)", sline)
                 if m: self.encoding = m.group(1)
                 if m: line = line.replace('coding','coding (removed)')
-            if line.strip()[:2].count('%') == 1:
+            if sline and sline[0] == '%' and sline[:2] != '%%':
                 line = line.split('%',1)[1].lstrip() # Full line following the %
                 cline = self.split_comment(line).strip()
                 cmd = re.split(r'[^a-zA-Z0-9_]', cline)[0]
@@ -2768,21 +3094,22 @@ def template(*args, **kwargs):
     or directly (as keyword arguments).
     '''
     tpl = args[0] if args else None
-    template_adapter = kwargs.pop('template_adapter', SimpleTemplate)
-    if tpl not in TEMPLATES or DEBUG:
+    adapter = kwargs.pop('template_adapter', SimpleTemplate)
+    lookup = kwargs.pop('template_lookup', TEMPLATE_PATH)
+    tplid = (id(lookup), tpl)
+    if tplid not in TEMPLATES or DEBUG:
         settings = kwargs.pop('template_settings', {})
-        lookup = kwargs.pop('template_lookup', TEMPLATE_PATH)
-        if isinstance(tpl, template_adapter):
-            TEMPLATES[tpl] = tpl
-            if settings: TEMPLATES[tpl].prepare(**settings)
+        if isinstance(tpl, adapter):
+            TEMPLATES[tplid] = tpl
+            if settings: TEMPLATES[tplid].prepare(**settings)
         elif "\n" in tpl or "{" in tpl or "%" in tpl or '$' in tpl:
-            TEMPLATES[tpl] = template_adapter(source=tpl, lookup=lookup, **settings)
+            TEMPLATES[tplid] = adapter(source=tpl, lookup=lookup, **settings)
         else:
-            TEMPLATES[tpl] = template_adapter(name=tpl, lookup=lookup, **settings)
-    if not TEMPLATES[tpl]:
+            TEMPLATES[tplid] = adapter(name=tpl, lookup=lookup, **settings)
+    if not TEMPLATES[tplid]:
         abort(500, 'Template (%s) not found' % tpl)
     for dictarg in args[1:]: kwargs.update(dictarg)
-    return TEMPLATES[tpl].render(kwargs)
+    return TEMPLATES[tplid].render(kwargs)
 
 mako_template = functools.partial(template, template_adapter=MakoTemplate)
 cheetah_template = functools.partial(template, template_adapter=CheetahTemplate)
@@ -2839,17 +3166,16 @@ HTTP_CODES[428] = "Precondition Required"
 HTTP_CODES[429] = "Too Many Requests"
 HTTP_CODES[431] = "Request Header Fields Too Large"
 HTTP_CODES[511] = "Network Authentication Required"
-_HTTP_STATUS_LINES = dict((k, '%d %s'%(k,v)) for (k,v) in HTTP_CODES.iteritems())
+_HTTP_STATUS_LINES = dict((k, '%d %s'%(k,v)) for (k,v) in HTTP_CODES.items())
 
 #: The default template used for error pages. Override with @error()
 ERROR_PAGE_TEMPLATE = """
-%try:
-    %from bottle import DEBUG, HTTP_CODES, request, touni
-    %status_name = HTTP_CODES.get(e.status, 'Unknown').title()
+%%try:
+    %%from %s import DEBUG, HTTP_CODES, request, touni
     <!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
     <html>
         <head>
-            <title>Error {{e.status}}: {{status_name}}</title>
+            <title>Error: {{e.status}}</title>
             <style type="text/css">
               html {background-color: #eee; font-family: sans;}
               body {background-color: #fff; border: 1px solid #ddd;
@@ -2858,31 +3184,34 @@ ERROR_PAGE_TEMPLATE = """
             </style>
         </head>
         <body>
-            <h1>Error {{e.status}}: {{status_name}}</h1>
+            <h1>Error: {{e.status}}</h1>
             <p>Sorry, the requested URL <tt>{{repr(request.url)}}</tt>
                caused an error:</p>
-            <pre>{{e.output}}</pre>
-            %if DEBUG and e.exception:
+            <pre>{{e.body}}</pre>
+            %%if DEBUG and e.exception:
               <h2>Exception:</h2>
               <pre>{{repr(e.exception)}}</pre>
-            %end
-            %if DEBUG and e.traceback:
+            %%end
+            %%if DEBUG and e.traceback:
               <h2>Traceback:</h2>
               <pre>{{e.traceback}}</pre>
-            %end
+            %%end
         </body>
     </html>
-%except ImportError:
+%%except ImportError:
     <b>ImportError:</b> Could not generate the error page. Please add bottle to
     the import path.
-%end
-"""
+%%end
+""" % __name__
 
-#: A thread-safe instance of :class:`Request` representing the `current` request.
-request = Request()
+#: A thread-safe instance of :class:`LocalRequest`. If accessed from within a
+#: request callback, this instance always refers to the *current* request
+#: (even on a multithreaded server).
+request = LocalRequest()
 
-#: A thread-safe instance of :class:`Response` used to build the HTTP response.
-response = Response()
+#: A thread-safe instance of :class:`LocalResponse`. It is used to change the
+#: HTTP response for the *current* request.
+response = LocalResponse()
 
 #: A thread-safe namespace. Not used by Bottle.
 local = threading.local()
@@ -2894,29 +3223,29 @@ app.push()
 
 #: A virtual package that redirects import statements.
 #: Example: ``import bottle.ext.sqlite`` actually imports `bottle_sqlite`.
-ext = _ImportRedirect(__name__+'.ext', 'bottle_%s').module
+ext = _ImportRedirect('bottle.ext' if __name__ == '__main__' else __name__+".ext", 'bottle_%s').module
 
 if __name__ == '__main__':
     opt, args, parser = _cmd_options, _cmd_args, _cmd_parser
     if opt.version:
-        print 'Bottle', __version__; sys.exit(0)
+        _stdout('Bottle %s\n'%__version__)
+        sys.exit(0)
     if not args:
         parser.print_help()
-        print '\nError: No application specified.\n'
+        _stderr('\nError: No application specified.\n')
         sys.exit(1)
 
-    try:
-        sys.path.insert(0, '.')
-        sys.modules.setdefault('bottle', sys.modules['__main__'])
-    except (AttributeError, ImportError), e:
-        parser.error(e.args[0])
+    sys.path.insert(0, '.')
+    sys.modules.setdefault('bottle', sys.modules['__main__'])
+
+    host, port = (opt.bind or 'localhost'), 8080
+    if ':' in host:
+        host, port = host.rsplit(':', 1)
+
+    run(args[0], host=host, port=port, server=opt.server,
+        reloader=opt.reload, plugins=opt.plugin, debug=opt.debug)
+
 
-    if opt.bind and ':' in opt.bind:
-        host, port = opt.bind.rsplit(':', 1)
-    else:
-        host, port = (opt.bind or 'localhost'), 8080
 
-    debug(opt.debug)
-    run(args[0], host=host, port=port, server=opt.server, reloader=opt.reload, plugins=opt.plugin)
 
 # THE END
diff --git a/module/lib/feedparser.py b/module/lib/feedparser.py
deleted file mode 100644
index a746ed8f5..000000000
--- a/module/lib/feedparser.py
+++ /dev/null
@@ -1,3885 +0,0 @@
-#!/usr/bin/env python
-"""Universal feed parser
-
-Handles RSS 0.9x, RSS 1.0, RSS 2.0, CDF, Atom 0.3, and Atom 1.0 feeds
-
-Visit http://feedparser.org/ for the latest version
-Visit http://feedparser.org/docs/ for the latest documentation
-
-Required: Python 2.4 or later
-Recommended: CJKCodecs and iconv_codec <http://cjkpython.i18n.org/>
-"""
-
-__version__ = "5.0"
-__license__ = """Copyright (c) 2002-2008, Mark Pilgrim, All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-* Redistributions of source code must retain the above copyright notice,
-  this list of conditions and the following disclaimer.
-* Redistributions in binary form must reproduce the above copyright notice,
-  this list of conditions and the following disclaimer in the documentation
-  and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS'
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGE."""
-__author__ = "Mark Pilgrim <http://diveintomark.org/>"
-__contributors__ = ["Jason Diamond <http://injektilo.org/>",
-                    "John Beimler <http://john.beimler.org/>",
-                    "Fazal Majid <http://www.majid.info/mylos/weblog/>",
-                    "Aaron Swartz <http://aaronsw.com/>",
-                    "Kevin Marks <http://epeus.blogspot.com/>",
-                    "Sam Ruby <http://intertwingly.net/>",
-                    "Ade Oshineye <http://blog.oshineye.com/>",
-                    "Martin Pool <http://sourcefrog.net/>",
-                    "Kurt McKee <http://kurtmckee.org/>"]
-_debug = 0
-
-# HTTP "User-Agent" header to send to servers when downloading feeds.
-# If you are embedding feedparser in a larger application, you should
-# change this to your application name and URL.
-USER_AGENT = "UniversalFeedParser/%s +http://feedparser.org/" % __version__
-
-# HTTP "Accept" header to send to servers when downloading feeds.  If you don't
-# want to send an Accept header, set this to None.
-ACCEPT_HEADER = "application/atom+xml,application/rdf+xml,application/rss+xml,application/x-netcdf,application/xml;q=0.9,text/xml;q=0.2,*/*;q=0.1"
-
-# List of preferred XML parsers, by SAX driver name.  These will be tried first,
-# but if they're not installed, Python will keep searching through its own list
-# of pre-installed parsers until it finds one that supports everything we need.
-PREFERRED_XML_PARSERS = ["drv_libxml2"]
-
-# If you want feedparser to automatically run HTML markup through HTML Tidy, set
-# this to 1.  Requires mxTidy <http://www.egenix.com/files/python/mxTidy.html>
-# or utidylib <http://utidylib.berlios.de/>.
-TIDY_MARKUP = 0
-
-# List of Python interfaces for HTML Tidy, in order of preference.  Only useful
-# if TIDY_MARKUP = 1
-PREFERRED_TIDY_INTERFACES = ["uTidy", "mxTidy"]
-
-# If you want feedparser to automatically resolve all relative URIs, set this
-# to 1.
-RESOLVE_RELATIVE_URIS = 1
-
-# If you want feedparser to automatically sanitize all potentially unsafe
-# HTML content, set this to 1.
-SANITIZE_HTML = 1
-
-# ---------- Python 3 modules (make it work if possible) ----------
-try:
-    import rfc822
-except ImportError:
-    from email import _parseaddr as rfc822
-
-try:
-    # Python 3.1 introduces bytes.maketrans and simultaneously
-    # deprecates string.maketrans; use bytes.maketrans if possible
-    _maketrans = bytes.maketrans
-except (NameError, AttributeError):
-    import string
-    _maketrans = string.maketrans
-    
-# base64 support for Atom feeds that contain embedded binary data
-try:
-    import base64, binascii
-    # Python 3.1 deprecates decodestring in favor of decodebytes
-    _base64decode = getattr(base64, 'decodebytes', base64.decodestring)
-except:
-    base64 = binascii = None
-
-def _s2bytes(s):
-  # Convert a UTF-8 str to bytes if the interpreter is Python 3
-  try:
-    return bytes(s, 'utf8')
-  except (NameError, TypeError):
-    # In Python 2.5 and below, bytes doesn't exist (NameError)
-    # In Python 2.6 and above, bytes and str are the same (TypeError)
-    return s
-
-def _l2bytes(l):
-  # Convert a list of ints to bytes if the interpreter is Python 3
-  try:
-    if bytes is not str:
-      # In Python 2.6 and above, this call won't raise an exception
-      # but it will return bytes([65]) as '[65]' instead of 'A'
-      return bytes(l)
-    raise NameError
-  except NameError:
-    return ''.join(map(chr, l))
-
-# If you want feedparser to allow all URL schemes, set this to ()
-# List culled from Python's urlparse documentation at:
-#   http://docs.python.org/library/urlparse.html
-# as well as from "URI scheme" at Wikipedia:
-#   https://secure.wikimedia.org/wikipedia/en/wiki/URI_scheme
-# Many more will likely need to be added!
-ACCEPTABLE_URI_SCHEMES = (
-    'file', 'ftp', 'gopher', 'h323', 'hdl', 'http', 'https', 'imap', 'mailto',
-    'mms', 'news', 'nntp', 'prospero', 'rsync', 'rtsp', 'rtspu', 'sftp',
-    'shttp', 'sip', 'sips', 'snews', 'svn', 'svn+ssh', 'telnet', 'wais',
-    # Additional common-but-unofficial schemes
-    'aim', 'callto', 'cvs', 'facetime', 'feed', 'git', 'gtalk', 'irc', 'ircs',
-    'irc6', 'itms', 'mms', 'msnim', 'skype', 'ssh', 'smb', 'svn', 'ymsg',
-)
-#ACCEPTABLE_URI_SCHEMES = ()
-
-# ---------- required modules (should come with any Python distribution) ----------
-import sgmllib, re, sys, copy, urlparse, time, types, cgi, urllib, urllib2, datetime
-try:
-    from io import BytesIO as _StringIO
-except ImportError:
-    try:
-        from cStringIO import StringIO as _StringIO
-    except:
-        from StringIO import StringIO as _StringIO
-
-# ---------- optional modules (feedparser will work without these, but with reduced functionality) ----------
-
-# gzip is included with most Python distributions, but may not be available if you compiled your own
-try:
-    import gzip
-except:
-    gzip = None
-try:
-    import zlib
-except:
-    zlib = None
-
-# If a real XML parser is available, feedparser will attempt to use it.  feedparser has
-# been tested with the built-in SAX parser, PyXML, and libxml2.  On platforms where the
-# Python distribution does not come with an XML parser (such as Mac OS X 10.2 and some
-# versions of FreeBSD), feedparser will quietly fall back on regex-based parsing.
-try:
-    import xml.sax
-    xml.sax.make_parser(PREFERRED_XML_PARSERS) # test for valid parsers
-    from xml.sax.saxutils import escape as _xmlescape
-    _XML_AVAILABLE = 1
-except:
-    _XML_AVAILABLE = 0
-    def _xmlescape(data,entities={}):
-        data = data.replace('&', '&amp;')
-        data = data.replace('>', '&gt;')
-        data = data.replace('<', '&lt;')
-        for char, entity in entities:
-            data = data.replace(char, entity)
-        return data
-
-# cjkcodecs and iconv_codec provide support for more character encodings.
-# Both are available from http://cjkpython.i18n.org/
-try:
-    import cjkcodecs.aliases
-except:
-    pass
-try:
-    import iconv_codec
-except:
-    pass
-
-# chardet library auto-detects character encodings
-# Download from http://chardet.feedparser.org/
-try:
-    import chardet
-    if _debug:
-        import chardet.constants
-        chardet.constants._debug = 1
-except:
-    chardet = None
-
-# reversable htmlentitydefs mappings for Python 2.2
-try:
-  from htmlentitydefs import name2codepoint, codepoint2name
-except:
-  import htmlentitydefs
-  name2codepoint={}
-  codepoint2name={}
-  for (name,codepoint) in htmlentitydefs.entitydefs.iteritems():
-    if codepoint.startswith('&#'): codepoint=unichr(int(codepoint[2:-1]))
-    name2codepoint[name]=ord(codepoint)
-    codepoint2name[ord(codepoint)]=name
-
-# BeautifulSoup parser used for parsing microformats from embedded HTML content
-# http://www.crummy.com/software/BeautifulSoup/
-# feedparser is tested with BeautifulSoup 3.0.x, but it might work with the
-# older 2.x series.  If it doesn't, and you can figure out why, I'll accept a
-# patch and modify the compatibility statement accordingly.
-try:
-    import BeautifulSoup
-except:
-    BeautifulSoup = None
-
-# ---------- don't touch these ----------
-class ThingsNobodyCaresAboutButMe(Exception): pass
-class CharacterEncodingOverride(ThingsNobodyCaresAboutButMe): pass
-class CharacterEncodingUnknown(ThingsNobodyCaresAboutButMe): pass
-class NonXMLContentType(ThingsNobodyCaresAboutButMe): pass
-class UndeclaredNamespace(Exception): pass
-
-sgmllib.tagfind = re.compile('[a-zA-Z][-_.:a-zA-Z0-9]*')
-sgmllib.special = re.compile('<!')
-sgmllib.charref = re.compile('&#(\d+|[xX][0-9a-fA-F]+);')
-
-if sgmllib.endbracket.search(' <').start(0):
-    class EndBracketRegEx:
-        def __init__(self):
-            # Overriding the built-in sgmllib.endbracket regex allows the
-            # parser to find angle brackets embedded in element attributes.
-            self.endbracket = re.compile('''([^'"<>]|"[^"]*"(?=>|/|\s|\w+=)|'[^']*'(?=>|/|\s|\w+=))*(?=[<>])|.*?(?=[<>])''')
-        def search(self,string,index=0):
-            match = self.endbracket.match(string,index)
-            if match is not None:
-                # Returning a new object in the calling thread's context
-                # resolves a thread-safety.
-                return EndBracketMatch(match) 
-            return None
-    class EndBracketMatch:
-        def __init__(self, match):
-            self.match = match
-        def start(self, n):
-            return self.match.end(n)
-    sgmllib.endbracket = EndBracketRegEx()
-
-SUPPORTED_VERSIONS = {'': 'unknown',
-                      'rss090': 'RSS 0.90',
-                      'rss091n': 'RSS 0.91 (Netscape)',
-                      'rss091u': 'RSS 0.91 (Userland)',
-                      'rss092': 'RSS 0.92',
-                      'rss093': 'RSS 0.93',
-                      'rss094': 'RSS 0.94',
-                      'rss20': 'RSS 2.0',
-                      'rss10': 'RSS 1.0',
-                      'rss': 'RSS (unknown version)',
-                      'atom01': 'Atom 0.1',
-                      'atom02': 'Atom 0.2',
-                      'atom03': 'Atom 0.3',
-                      'atom10': 'Atom 1.0',
-                      'atom': 'Atom (unknown version)',
-                      'cdf': 'CDF',
-                      'hotrss': 'Hot RSS'
-                      }
-
-try:
-    UserDict = dict
-except NameError:
-    # Python 2.1 does not have dict
-    from UserDict import UserDict
-    def dict(aList):
-        rc = {}
-        for k, v in aList:
-            rc[k] = v
-        return rc
-
-class FeedParserDict(UserDict):
-    keymap = {'channel': 'feed',
-              'items': 'entries',
-              'guid': 'id',
-              'date': 'updated',
-              'date_parsed': 'updated_parsed',
-              'description': ['summary', 'subtitle'],
-              'url': ['href'],
-              'modified': 'updated',
-              'modified_parsed': 'updated_parsed',
-              'issued': 'published',
-              'issued_parsed': 'published_parsed',
-              'copyright': 'rights',
-              'copyright_detail': 'rights_detail',
-              'tagline': 'subtitle',
-              'tagline_detail': 'subtitle_detail'}
-    def __getitem__(self, key):
-        if key == 'category':
-            return UserDict.__getitem__(self, 'tags')[0]['term']
-        if key == 'enclosures':
-            norel = lambda link: FeedParserDict([(name,value) for (name,value) in link.items() if name!='rel'])
-            return [norel(link) for link in UserDict.__getitem__(self, 'links') if link['rel']=='enclosure']
-        if key == 'license':
-            for link in UserDict.__getitem__(self, 'links'):
-                if link['rel']=='license' and link.has_key('href'):
-                    return link['href']
-        if key == 'categories':
-            return [(tag['scheme'], tag['term']) for tag in UserDict.__getitem__(self, 'tags')]
-        realkey = self.keymap.get(key, key)
-        if type(realkey) == types.ListType:
-            for k in realkey:
-                if UserDict.__contains__(self, k):
-                    return UserDict.__getitem__(self, k)
-        if UserDict.__contains__(self, key):
-            return UserDict.__getitem__(self, key)
-        return UserDict.__getitem__(self, realkey)
-
-    def __setitem__(self, key, value):
-        for k in self.keymap.keys():
-            if key == k:
-                key = self.keymap[k]
-                if type(key) == types.ListType:
-                    key = key[0]
-        return UserDict.__setitem__(self, key, value)
-
-    def get(self, key, default=None):
-        if self.has_key(key):
-            return self[key]
-        else:
-            return default
-
-    def setdefault(self, key, value):
-        if not self.has_key(key):
-            self[key] = value
-        return self[key]
-        
-    def has_key(self, key):
-        try:
-            return hasattr(self, key) or UserDict.__contains__(self, key)
-        except AttributeError:
-            return False
-    # This alias prevents the 2to3 tool from changing the semantics of the
-    # __contains__ function below and exhausting the maximum recursion depth
-    __has_key = has_key
-        
-    def __getattr__(self, key):
-        try:
-            return self.__dict__[key]
-        except KeyError:
-            pass
-        try:
-            assert not key.startswith('_')
-            return self.__getitem__(key)
-        except:
-            raise AttributeError, "object has no attribute '%s'" % key
-
-    def __setattr__(self, key, value):
-        if key.startswith('_') or key == 'data':
-            self.__dict__[key] = value
-        else:
-            return self.__setitem__(key, value)
-
-    def __contains__(self, key):
-        return self.__has_key(key)
-
-def zopeCompatibilityHack():
-    global FeedParserDict
-    del FeedParserDict
-    def FeedParserDict(aDict=None):
-        rc = {}
-        if aDict:
-            rc.update(aDict)
-        return rc
-
-_ebcdic_to_ascii_map = None
-def _ebcdic_to_ascii(s):
-    global _ebcdic_to_ascii_map
-    if not _ebcdic_to_ascii_map:
-        emap = (
-            0,1,2,3,156,9,134,127,151,141,142,11,12,13,14,15,
-            16,17,18,19,157,133,8,135,24,25,146,143,28,29,30,31,
-            128,129,130,131,132,10,23,27,136,137,138,139,140,5,6,7,
-            144,145,22,147,148,149,150,4,152,153,154,155,20,21,158,26,
-            32,160,161,162,163,164,165,166,167,168,91,46,60,40,43,33,
-            38,169,170,171,172,173,174,175,176,177,93,36,42,41,59,94,
-            45,47,178,179,180,181,182,183,184,185,124,44,37,95,62,63,
-            186,187,188,189,190,191,192,193,194,96,58,35,64,39,61,34,
-            195,97,98,99,100,101,102,103,104,105,196,197,198,199,200,201,
-            202,106,107,108,109,110,111,112,113,114,203,204,205,206,207,208,
-            209,126,115,116,117,118,119,120,121,122,210,211,212,213,214,215,
-            216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,
-            123,65,66,67,68,69,70,71,72,73,232,233,234,235,236,237,
-            125,74,75,76,77,78,79,80,81,82,238,239,240,241,242,243,
-            92,159,83,84,85,86,87,88,89,90,244,245,246,247,248,249,
-            48,49,50,51,52,53,54,55,56,57,250,251,252,253,254,255
-            )
-        _ebcdic_to_ascii_map = _maketrans( \
-            _l2bytes(range(256)), _l2bytes(emap))
-    return s.translate(_ebcdic_to_ascii_map)
- 
-_cp1252 = {
-  unichr(128): unichr(8364), # euro sign
-  unichr(130): unichr(8218), # single low-9 quotation mark
-  unichr(131): unichr( 402), # latin small letter f with hook
-  unichr(132): unichr(8222), # double low-9 quotation mark
-  unichr(133): unichr(8230), # horizontal ellipsis
-  unichr(134): unichr(8224), # dagger
-  unichr(135): unichr(8225), # double dagger
-  unichr(136): unichr( 710), # modifier letter circumflex accent
-  unichr(137): unichr(8240), # per mille sign
-  unichr(138): unichr( 352), # latin capital letter s with caron
-  unichr(139): unichr(8249), # single left-pointing angle quotation mark
-  unichr(140): unichr( 338), # latin capital ligature oe
-  unichr(142): unichr( 381), # latin capital letter z with caron
-  unichr(145): unichr(8216), # left single quotation mark
-  unichr(146): unichr(8217), # right single quotation mark
-  unichr(147): unichr(8220), # left double quotation mark
-  unichr(148): unichr(8221), # right double quotation mark
-  unichr(149): unichr(8226), # bullet
-  unichr(150): unichr(8211), # en dash
-  unichr(151): unichr(8212), # em dash
-  unichr(152): unichr( 732), # small tilde
-  unichr(153): unichr(8482), # trade mark sign
-  unichr(154): unichr( 353), # latin small letter s with caron
-  unichr(155): unichr(8250), # single right-pointing angle quotation mark
-  unichr(156): unichr( 339), # latin small ligature oe
-  unichr(158): unichr( 382), # latin small letter z with caron
-  unichr(159): unichr( 376)} # latin capital letter y with diaeresis
-
-_urifixer = re.compile('^([A-Za-z][A-Za-z0-9+-.]*://)(/*)(.*?)')
-def _urljoin(base, uri):
-    uri = _urifixer.sub(r'\1\3', uri)
-    try:
-        return urlparse.urljoin(base, uri)
-    except:
-        uri = urlparse.urlunparse([urllib.quote(part) for part in urlparse.urlparse(uri)])
-        return urlparse.urljoin(base, uri)
-
-class _FeedParserMixin:
-    namespaces = {'': '',
-                  'http://backend.userland.com/rss': '',
-                  'http://blogs.law.harvard.edu/tech/rss': '',
-                  'http://purl.org/rss/1.0/': '',
-                  'http://my.netscape.com/rdf/simple/0.9/': '',
-                  'http://example.com/newformat#': '',
-                  'http://example.com/necho': '',
-                  'http://purl.org/echo/': '',
-                  'uri/of/echo/namespace#': '',
-                  'http://purl.org/pie/': '',
-                  'http://purl.org/atom/ns#': '',
-                  'http://www.w3.org/2005/Atom': '',
-                  'http://purl.org/rss/1.0/modules/rss091#': '',
-                  
-                  'http://webns.net/mvcb/':                               'admin',
-                  'http://purl.org/rss/1.0/modules/aggregation/':         'ag',
-                  'http://purl.org/rss/1.0/modules/annotate/':            'annotate',
-                  'http://media.tangent.org/rss/1.0/':                    'audio',
-                  'http://backend.userland.com/blogChannelModule':        'blogChannel',
-                  'http://web.resource.org/cc/':                          'cc',
-                  'http://backend.userland.com/creativeCommonsRssModule': 'creativeCommons',
-                  'http://purl.org/rss/1.0/modules/company':              'co',
-                  'http://purl.org/rss/1.0/modules/content/':             'content',
-                  'http://my.theinfo.org/changed/1.0/rss/':               'cp',
-                  'http://purl.org/dc/elements/1.1/':                     'dc',
-                  'http://purl.org/dc/terms/':                            'dcterms',
-                  'http://purl.org/rss/1.0/modules/email/':               'email',
-                  'http://purl.org/rss/1.0/modules/event/':               'ev',
-                  'http://rssnamespace.org/feedburner/ext/1.0':           'feedburner',
-                  'http://freshmeat.net/rss/fm/':                         'fm',
-                  'http://xmlns.com/foaf/0.1/':                           'foaf',
-                  'http://www.w3.org/2003/01/geo/wgs84_pos#':             'geo',
-                  'http://postneo.com/icbm/':                             'icbm',
-                  'http://purl.org/rss/1.0/modules/image/':               'image',
-                  'http://www.itunes.com/DTDs/PodCast-1.0.dtd':           'itunes',
-                  'http://example.com/DTDs/PodCast-1.0.dtd':              'itunes',
-                  'http://purl.org/rss/1.0/modules/link/':                'l',
-                  'http://search.yahoo.com/mrss':                         'media',
-                  #Version 1.1.2 of the Media RSS spec added the trailing slash on the namespace
-                  'http://search.yahoo.com/mrss/':                         'media',
-                  'http://madskills.com/public/xml/rss/module/pingback/': 'pingback',
-                  'http://prismstandard.org/namespaces/1.2/basic/':       'prism',
-                  'http://www.w3.org/1999/02/22-rdf-syntax-ns#':          'rdf',
-                  'http://www.w3.org/2000/01/rdf-schema#':                'rdfs',
-                  'http://purl.org/rss/1.0/modules/reference/':           'ref',
-                  'http://purl.org/rss/1.0/modules/richequiv/':           'reqv',
-                  'http://purl.org/rss/1.0/modules/search/':              'search',
-                  'http://purl.org/rss/1.0/modules/slash/':               'slash',
-                  'http://schemas.xmlsoap.org/soap/envelope/':            'soap',
-                  'http://purl.org/rss/1.0/modules/servicestatus/':       'ss',
-                  'http://hacks.benhammersley.com/rss/streaming/':        'str',
-                  'http://purl.org/rss/1.0/modules/subscription/':        'sub',
-                  'http://purl.org/rss/1.0/modules/syndication/':         'sy',
-                  'http://schemas.pocketsoap.com/rss/myDescModule/':      'szf',
-                  'http://purl.org/rss/1.0/modules/taxonomy/':            'taxo',
-                  'http://purl.org/rss/1.0/modules/threading/':           'thr',
-                  'http://purl.org/rss/1.0/modules/textinput/':           'ti',
-                  'http://madskills.com/public/xml/rss/module/trackback/':'trackback',
-                  'http://wellformedweb.org/commentAPI/':                 'wfw',
-                  'http://purl.org/rss/1.0/modules/wiki/':                'wiki',
-                  'http://www.w3.org/1999/xhtml':                         'xhtml',
-                  'http://www.w3.org/1999/xlink':                         'xlink',
-                  'http://www.w3.org/XML/1998/namespace':                 'xml'
-}
-    _matchnamespaces = {}
-
-    can_be_relative_uri = ['link', 'id', 'wfw_comment', 'wfw_commentrss', 'docs', 'url', 'href', 'comments', 'icon', 'logo']
-    can_contain_relative_uris = ['content', 'title', 'summary', 'info', 'tagline', 'subtitle', 'copyright', 'rights', 'description']
-    can_contain_dangerous_markup = ['content', 'title', 'summary', 'info', 'tagline', 'subtitle', 'copyright', 'rights', 'description']
-    html_types = ['text/html', 'application/xhtml+xml']
-    
-    def __init__(self, baseuri=None, baselang=None, encoding='utf-8'):
-        if _debug: sys.stderr.write('initializing FeedParser\n')
-        if not self._matchnamespaces:
-            for k, v in self.namespaces.items():
-                self._matchnamespaces[k.lower()] = v
-        self.feeddata = FeedParserDict() # feed-level data
-        self.encoding = encoding # character encoding
-        self.entries = [] # list of entry-level data
-        self.version = '' # feed type/version, see SUPPORTED_VERSIONS
-        self.namespacesInUse = {} # dictionary of namespaces defined by the feed
-
-        # the following are used internally to track state;
-        # this is really out of control and should be refactored
-        self.infeed = 0
-        self.inentry = 0
-        self.incontent = 0
-        self.intextinput = 0
-        self.inimage = 0
-        self.inauthor = 0
-        self.incontributor = 0
-        self.inpublisher = 0
-        self.insource = 0
-        self.sourcedata = FeedParserDict()
-        self.contentparams = FeedParserDict()
-        self._summaryKey = None
-        self.namespacemap = {}
-        self.elementstack = []
-        self.basestack = []
-        self.langstack = []
-        self.baseuri = baseuri or ''
-        self.lang = baselang or None
-        self.svgOK = 0
-        self.hasTitle = 0
-        if baselang:
-            self.feeddata['language'] = baselang.replace('_','-')
-
-    def unknown_starttag(self, tag, attrs):
-        if _debug: sys.stderr.write('start %s with %s\n' % (tag, attrs))
-        # normalize attrs
-        attrs = [(k.lower(), v) for k, v in attrs]
-        attrs = [(k, k in ('rel', 'type') and v.lower() or v) for k, v in attrs]
-        # the sgml parser doesn't handle entities in attributes, but
-        # strict xml parsers do -- account for this difference
-        if isinstance(self, _LooseFeedParser):
-            attrs = [(k, v.replace('&amp;', '&')) for k, v in attrs]
-        
-        # track xml:base and xml:lang
-        attrsD = dict(attrs)
-        baseuri = attrsD.get('xml:base', attrsD.get('base')) or self.baseuri
-        if type(baseuri) != type(u''):
-            try:
-                baseuri = unicode(baseuri, self.encoding)
-            except:
-                baseuri = unicode(baseuri, 'iso-8859-1')
-        # ensure that self.baseuri is always an absolute URI that
-        # uses a whitelisted URI scheme (e.g. not `javscript:`)
-        if self.baseuri:
-            self.baseuri = _makeSafeAbsoluteURI(self.baseuri, baseuri) or self.baseuri
-        else:
-            self.baseuri = _urljoin(self.baseuri, baseuri)
-        lang = attrsD.get('xml:lang', attrsD.get('lang'))
-        if lang == '':
-            # xml:lang could be explicitly set to '', we need to capture that
-            lang = None
-        elif lang is None:
-            # if no xml:lang is specified, use parent lang
-            lang = self.lang
-        if lang:
-            if tag in ('feed', 'rss', 'rdf:RDF'):
-                self.feeddata['language'] = lang.replace('_','-')
-        self.lang = lang
-        self.basestack.append(self.baseuri)
-        self.langstack.append(lang)
-        
-        # track namespaces
-        for prefix, uri in attrs:
-            if prefix.startswith('xmlns:'):
-                self.trackNamespace(prefix[6:], uri)
-            elif prefix == 'xmlns':
-                self.trackNamespace(None, uri)
-
-        # track inline content
-        if self.incontent and self.contentparams.has_key('type') and not self.contentparams.get('type', 'xml').endswith('xml'):
-            if tag in ['xhtml:div', 'div']: return # typepad does this 10/2007
-            # element declared itself as escaped markup, but it isn't really
-            self.contentparams['type'] = 'application/xhtml+xml'
-        if self.incontent and self.contentparams.get('type') == 'application/xhtml+xml':
-            if tag.find(':') <> -1:
-                prefix, tag = tag.split(':', 1)
-                namespace = self.namespacesInUse.get(prefix, '')
-                if tag=='math' and namespace=='http://www.w3.org/1998/Math/MathML':
-                    attrs.append(('xmlns',namespace))
-                if tag=='svg' and namespace=='http://www.w3.org/2000/svg':
-                    attrs.append(('xmlns',namespace))
-            if tag == 'svg': self.svgOK += 1
-            return self.handle_data('<%s%s>' % (tag, self.strattrs(attrs)), escape=0)
-
-        # match namespaces
-        if tag.find(':') <> -1:
-            prefix, suffix = tag.split(':', 1)
-        else:
-            prefix, suffix = '', tag
-        prefix = self.namespacemap.get(prefix, prefix)
-        if prefix:
-            prefix = prefix + '_'
-
-        # special hack for better tracking of empty textinput/image elements in illformed feeds
-        if (not prefix) and tag not in ('title', 'link', 'description', 'name'):
-            self.intextinput = 0
-        if (not prefix) and tag not in ('title', 'link', 'description', 'url', 'href', 'width', 'height'):
-            self.inimage = 0
-        
-        # call special handler (if defined) or default handler
-        methodname = '_start_' + prefix + suffix
-        try:
-            method = getattr(self, methodname)
-            return method(attrsD)
-        except AttributeError:
-            # Since there's no handler or something has gone wrong we explicitly add the element and its attributes
-            unknown_tag = prefix + suffix
-            if len(attrsD) == 0:
-                # No attributes so merge it into the encosing dictionary
-                return self.push(unknown_tag, 1)
-            else:
-                # Has attributes so create it in its own dictionary
-                context = self._getContext()
-                context[unknown_tag] = attrsD
-
-    def unknown_endtag(self, tag):
-        if _debug: sys.stderr.write('end %s\n' % tag)
-        # match namespaces
-        if tag.find(':') <> -1:
-            prefix, suffix = tag.split(':', 1)
-        else:
-            prefix, suffix = '', tag
-        prefix = self.namespacemap.get(prefix, prefix)
-        if prefix:
-            prefix = prefix + '_'
-        if suffix == 'svg' and self.svgOK: self.svgOK -= 1
-
-        # call special handler (if defined) or default handler
-        methodname = '_end_' + prefix + suffix
-        try:
-            if self.svgOK: raise AttributeError()
-            method = getattr(self, methodname)
-            method()
-        except AttributeError:
-            self.pop(prefix + suffix)
-
-        # track inline content
-        if self.incontent and self.contentparams.has_key('type') and not self.contentparams.get('type', 'xml').endswith('xml'):
-            # element declared itself as escaped markup, but it isn't really
-            if tag in ['xhtml:div', 'div']: return # typepad does this 10/2007
-            self.contentparams['type'] = 'application/xhtml+xml'
-        if self.incontent and self.contentparams.get('type') == 'application/xhtml+xml':
-            tag = tag.split(':')[-1]
-            self.handle_data('</%s>' % tag, escape=0)
-
-        # track xml:base and xml:lang going out of scope
-        if self.basestack:
-            self.basestack.pop()
-            if self.basestack and self.basestack[-1]:
-                self.baseuri = self.basestack[-1]
-        if self.langstack:
-            self.langstack.pop()
-            if self.langstack: # and (self.langstack[-1] is not None):
-                self.lang = self.langstack[-1]
-
-    def handle_charref(self, ref):
-        # called for each character reference, e.g. for '&#160;', ref will be '160'
-        if not self.elementstack: return
-        ref = ref.lower()
-        if ref in ('34', '38', '39', '60', '62', 'x22', 'x26', 'x27', 'x3c', 'x3e'):
-            text = '&#%s;' % ref
-        else:
-            if ref[0] == 'x':
-                c = int(ref[1:], 16)
-            else:
-                c = int(ref)
-            text = unichr(c).encode('utf-8')
-        self.elementstack[-1][2].append(text)
-
-    def handle_entityref(self, ref):
-        # called for each entity reference, e.g. for '&copy;', ref will be 'copy'
-        if not self.elementstack: return
-        if _debug: sys.stderr.write('entering handle_entityref with %s\n' % ref)
-        if ref in ('lt', 'gt', 'quot', 'amp', 'apos'):
-            text = '&%s;' % ref
-        elif ref in self.entities.keys():
-            text = self.entities[ref]
-            if text.startswith('&#') and text.endswith(';'):
-                return self.handle_entityref(text)
-        else:
-            try: name2codepoint[ref]
-            except KeyError: text = '&%s;' % ref
-            else: text = unichr(name2codepoint[ref]).encode('utf-8')
-        self.elementstack[-1][2].append(text)
-
-    def handle_data(self, text, escape=1):
-        # called for each block of plain text, i.e. outside of any tag and
-        # not containing any character or entity references
-        if not self.elementstack: return
-        if escape and self.contentparams.get('type') == 'application/xhtml+xml':
-            text = _xmlescape(text)
-        self.elementstack[-1][2].append(text)
-
-    def handle_comment(self, text):
-        # called for each comment, e.g. <!-- insert message here -->
-        pass
-
-    def handle_pi(self, text):
-        # called for each processing instruction, e.g. <?instruction>
-        pass
-
-    def handle_decl(self, text):
-        pass
-
-    def parse_declaration(self, i):
-        # override internal declaration handler to handle CDATA blocks
-        if _debug: sys.stderr.write('entering parse_declaration\n')
-        if self.rawdata[i:i+9] == '<![CDATA[':
-            k = self.rawdata.find(']]>', i)
-            if k == -1:
-                # CDATA block began but didn't finish
-                k = len(self.rawdata)
-                return k
-            self.handle_data(_xmlescape(self.rawdata[i+9:k]), 0)
-            return k+3
-        else:
-            k = self.rawdata.find('>', i)
-            if k >= 0:
-                return k+1
-            else:
-                # We have an incomplete CDATA block.
-                return k
-
-    def mapContentType(self, contentType):
-        contentType = contentType.lower()
-        if contentType == 'text':
-            contentType = 'text/plain'
-        elif contentType == 'html':
-            contentType = 'text/html'
-        elif contentType == 'xhtml':
-            contentType = 'application/xhtml+xml'
-        return contentType
-    
-    def trackNamespace(self, prefix, uri):
-        loweruri = uri.lower()
-        if (prefix, loweruri) == (None, 'http://my.netscape.com/rdf/simple/0.9/') and not self.version:
-            self.version = 'rss090'
-        if loweruri == 'http://purl.org/rss/1.0/' and not self.version:
-            self.version = 'rss10'
-        if loweruri == 'http://www.w3.org/2005/atom' and not self.version:
-            self.version = 'atom10'
-        if loweruri.find('backend.userland.com/rss') <> -1:
-            # match any backend.userland.com namespace
-            uri = 'http://backend.userland.com/rss'
-            loweruri = uri
-        if self._matchnamespaces.has_key(loweruri):
-            self.namespacemap[prefix] = self._matchnamespaces[loweruri]
-            self.namespacesInUse[self._matchnamespaces[loweruri]] = uri
-        else:
-            self.namespacesInUse[prefix or ''] = uri
-
-    def resolveURI(self, uri):
-        return _urljoin(self.baseuri or '', uri)
-    
-    def decodeEntities(self, element, data):
-        return data
-
-    def strattrs(self, attrs):
-        return ''.join([' %s="%s"' % (t[0],_xmlescape(t[1],{'"':'&quot;'})) for t in attrs])
-
-    def push(self, element, expectingText):
-        self.elementstack.append([element, expectingText, []])
-
-    def pop(self, element, stripWhitespace=1):
-        if not self.elementstack: return
-        if self.elementstack[-1][0] != element: return
-        
-        element, expectingText, pieces = self.elementstack.pop()
-
-        if self.version == 'atom10' and self.contentparams.get('type','text') == 'application/xhtml+xml':
-            # remove enclosing child element, but only if it is a <div> and
-            # only if all the remaining content is nested underneath it.
-            # This means that the divs would be retained in the following:
-            #    <div>foo</div><div>bar</div>
-            while pieces and len(pieces)>1 and not pieces[-1].strip():
-                del pieces[-1]
-            while pieces and len(pieces)>1 and not pieces[0].strip():
-                del pieces[0]
-            if pieces and (pieces[0] == '<div>' or pieces[0].startswith('<div ')) and pieces[-1]=='</div>':
-                depth = 0
-                for piece in pieces[:-1]:
-                    if piece.startswith('</'):
-                        depth -= 1
-                        if depth == 0: break
-                    elif piece.startswith('<') and not piece.endswith('/>'):
-                        depth += 1
-                else:
-                    pieces = pieces[1:-1]
-
-        # Ensure each piece is a str for Python 3
-        for (i, v) in enumerate(pieces):
-            if not isinstance(v, basestring):
-                pieces[i] = v.decode('utf-8')
-
-        output = ''.join(pieces)
-        if stripWhitespace:
-            output = output.strip()
-        if not expectingText: return output
-
-        # decode base64 content
-        if base64 and self.contentparams.get('base64', 0):
-            try:
-                output = _base64decode(output)
-            except binascii.Error:
-                pass
-            except binascii.Incomplete:
-                pass
-            except TypeError:
-                # In Python 3, base64 takes and outputs bytes, not str
-                # This may not be the most correct way to accomplish this
-                output = _base64decode(output.encode('utf-8')).decode('utf-8')
-                
-        # resolve relative URIs
-        if (element in self.can_be_relative_uri) and output:
-            output = self.resolveURI(output)
-        
-        # decode entities within embedded markup
-        if not self.contentparams.get('base64', 0):
-            output = self.decodeEntities(element, output)
-
-        if self.lookslikehtml(output):
-            self.contentparams['type']='text/html'
-
-        # remove temporary cruft from contentparams
-        try:
-            del self.contentparams['mode']
-        except KeyError:
-            pass
-        try:
-            del self.contentparams['base64']
-        except KeyError:
-            pass
-
-        is_htmlish = self.mapContentType(self.contentparams.get('type', 'text/html')) in self.html_types
-        # resolve relative URIs within embedded markup
-        if is_htmlish and RESOLVE_RELATIVE_URIS:
-            if element in self.can_contain_relative_uris:
-                output = _resolveRelativeURIs(output, self.baseuri, self.encoding, self.contentparams.get('type', 'text/html'))
-                
-        # parse microformats
-        # (must do this before sanitizing because some microformats
-        # rely on elements that we sanitize)
-        if is_htmlish and element in ['content', 'description', 'summary']:
-            mfresults = _parseMicroformats(output, self.baseuri, self.encoding)
-            if mfresults:
-                for tag in mfresults.get('tags', []):
-                    self._addTag(tag['term'], tag['scheme'], tag['label'])
-                for enclosure in mfresults.get('enclosures', []):
-                    self._start_enclosure(enclosure)
-                for xfn in mfresults.get('xfn', []):
-                    self._addXFN(xfn['relationships'], xfn['href'], xfn['name'])
-                vcard = mfresults.get('vcard')
-                if vcard:
-                    self._getContext()['vcard'] = vcard
-        
-        # sanitize embedded markup
-        if is_htmlish and SANITIZE_HTML:
-            if element in self.can_contain_dangerous_markup:
-                output = _sanitizeHTML(output, self.encoding, self.contentparams.get('type', 'text/html'))
-
-        if self.encoding and type(output) != type(u''):
-            try:
-                output = unicode(output, self.encoding)
-            except:
-                pass
-
-        # address common error where people take data that is already
-        # utf-8, presume that it is iso-8859-1, and re-encode it.
-        if self.encoding in ('utf-8', 'utf-8_INVALID_PYTHON_3') and type(output) == type(u''):
-            try:
-                output = unicode(output.encode('iso-8859-1'), 'utf-8')
-            except:
-                pass
-
-        # map win-1252 extensions to the proper code points
-        if type(output) == type(u''):
-            output = u''.join([c in _cp1252.keys() and _cp1252[c] or c for c in output])
-
-        # categories/tags/keywords/whatever are handled in _end_category
-        if element == 'category':
-            return output
-
-        if element == 'title' and self.hasTitle:
-            return output
-        
-        # store output in appropriate place(s)
-        if self.inentry and not self.insource:
-            if element == 'content':
-                self.entries[-1].setdefault(element, [])
-                contentparams = copy.deepcopy(self.contentparams)
-                contentparams['value'] = output
-                self.entries[-1][element].append(contentparams)
-            elif element == 'link':
-                if not self.inimage:
-                    # query variables in urls in link elements are improperly
-                    # converted from `?a=1&b=2` to `?a=1&b;=2` as if they're
-                    # unhandled character references. fix this special case.
-                    output = re.sub("&([A-Za-z0-9_]+);", "&\g<1>", output)
-                    self.entries[-1][element] = output
-                    if output:
-                        self.entries[-1]['links'][-1]['href'] = output
-            else:
-                if element == 'description':
-                    element = 'summary'
-                self.entries[-1][element] = output
-                if self.incontent:
-                    contentparams = copy.deepcopy(self.contentparams)
-                    contentparams['value'] = output
-                    self.entries[-1][element + '_detail'] = contentparams
-        elif (self.infeed or self.insource):# and (not self.intextinput) and (not self.inimage):
-            context = self._getContext()
-            if element == 'description':
-                element = 'subtitle'
-            context[element] = output
-            if element == 'link':
-                # fix query variables; see above for the explanation
-                output = re.sub("&([A-Za-z0-9_]+);", "&\g<1>", output)
-                context[element] = output
-                context['links'][-1]['href'] = output
-            elif self.incontent:
-                contentparams = copy.deepcopy(self.contentparams)
-                contentparams['value'] = output
-                context[element + '_detail'] = contentparams
-        return output
-
-    def pushContent(self, tag, attrsD, defaultContentType, expectingText):
-        self.incontent += 1
-        if self.lang: self.lang=self.lang.replace('_','-')
-        self.contentparams = FeedParserDict({
-            'type': self.mapContentType(attrsD.get('type', defaultContentType)),
-            'language': self.lang,
-            'base': self.baseuri})
-        self.contentparams['base64'] = self._isBase64(attrsD, self.contentparams)
-        self.push(tag, expectingText)
-
-    def popContent(self, tag):
-        value = self.pop(tag)
-        self.incontent -= 1
-        self.contentparams.clear()
-        return value
-        
-    # a number of elements in a number of RSS variants are nominally plain
-    # text, but this is routinely ignored.  This is an attempt to detect
-    # the most common cases.  As false positives often result in silent
-    # data loss, this function errs on the conservative side.
-    def lookslikehtml(self, s):
-        if self.version.startswith('atom'): return
-        if self.contentparams.get('type','text/html') != 'text/plain': return
-
-        # must have a close tag or a entity reference to qualify
-        if not (re.search(r'</(\w+)>',s) or re.search("&#?\w+;",s)): return
-
-        # all tags must be in a restricted subset of valid HTML tags
-        if filter(lambda t: t.lower() not in _HTMLSanitizer.acceptable_elements,
-            re.findall(r'</?(\w+)',s)): return
-
-        # all entities must have been defined as valid HTML entities
-        from htmlentitydefs import entitydefs
-        if filter(lambda e: e not in entitydefs.keys(),
-            re.findall(r'&(\w+);',s)): return
-
-        return 1
-
-    def _mapToStandardPrefix(self, name):
-        colonpos = name.find(':')
-        if colonpos <> -1:
-            prefix = name[:colonpos]
-            suffix = name[colonpos+1:]
-            prefix = self.namespacemap.get(prefix, prefix)
-            name = prefix + ':' + suffix
-        return name
-        
-    def _getAttribute(self, attrsD, name):
-        return attrsD.get(self._mapToStandardPrefix(name))
-
-    def _isBase64(self, attrsD, contentparams):
-        if attrsD.get('mode', '') == 'base64':
-            return 1
-        if self.contentparams['type'].startswith('text/'):
-            return 0
-        if self.contentparams['type'].endswith('+xml'):
-            return 0
-        if self.contentparams['type'].endswith('/xml'):
-            return 0
-        return 1
-
-    def _itsAnHrefDamnIt(self, attrsD):
-        href = attrsD.get('url', attrsD.get('uri', attrsD.get('href', None)))
-        if href:
-            try:
-                del attrsD['url']
-            except KeyError:
-                pass
-            try:
-                del attrsD['uri']
-            except KeyError:
-                pass
-            attrsD['href'] = href
-        return attrsD
-    
-    def _save(self, key, value, overwrite=False):
-        context = self._getContext()
-        if overwrite:
-            context[key] = value
-        else:
-            context.setdefault(key, value)
-
-    def _start_rss(self, attrsD):
-        versionmap = {'0.91': 'rss091u',
-                      '0.92': 'rss092',
-                      '0.93': 'rss093',
-                      '0.94': 'rss094'}
-        #If we're here then this is an RSS feed.
-        #If we don't have a version or have a version that starts with something
-        #other than RSS then there's been a mistake. Correct it.
-        if not self.version or not self.version.startswith('rss'):
-            attr_version = attrsD.get('version', '')
-            version = versionmap.get(attr_version)
-            if version:
-                self.version = version
-            elif attr_version.startswith('2.'):
-                self.version = 'rss20'
-            else:
-                self.version = 'rss'
-    
-    def _start_dlhottitles(self, attrsD):
-        self.version = 'hotrss'
-
-    def _start_channel(self, attrsD):
-        self.infeed = 1
-        self._cdf_common(attrsD)
-    _start_feedinfo = _start_channel
-
-    def _cdf_common(self, attrsD):
-        if attrsD.has_key('lastmod'):
-            self._start_modified({})
-            self.elementstack[-1][-1] = attrsD['lastmod']
-            self._end_modified()
-        if attrsD.has_key('href'):
-            self._start_link({})
-            self.elementstack[-1][-1] = attrsD['href']
-            self._end_link()
-    
-    def _start_feed(self, attrsD):
-        self.infeed = 1
-        versionmap = {'0.1': 'atom01',
-                      '0.2': 'atom02',
-                      '0.3': 'atom03'}
-        if not self.version:
-            attr_version = attrsD.get('version')
-            version = versionmap.get(attr_version)
-            if version:
-                self.version = version
-            else:
-                self.version = 'atom'
-
-    def _end_channel(self):
-        self.infeed = 0
-    _end_feed = _end_channel
-    
-    def _start_image(self, attrsD):
-        context = self._getContext()
-        if not self.inentry:
-            context.setdefault('image', FeedParserDict())
-        self.inimage = 1
-        self.hasTitle = 0
-        self.push('image', 0)
-            
-    def _end_image(self):
-        self.pop('image')
-        self.inimage = 0
-
-    def _start_textinput(self, attrsD):
-        context = self._getContext()
-        context.setdefault('textinput', FeedParserDict())
-        self.intextinput = 1
-        self.hasTitle = 0
-        self.push('textinput', 0)
-    _start_textInput = _start_textinput
-    
-    def _end_textinput(self):
-        self.pop('textinput')
-        self.intextinput = 0
-    _end_textInput = _end_textinput
-
-    def _start_author(self, attrsD):
-        self.inauthor = 1
-        self.push('author', 1)
-        # Append a new FeedParserDict when expecting an author
-        context = self._getContext()
-        context.setdefault('authors', [])
-        context['authors'].append(FeedParserDict())
-    _start_managingeditor = _start_author
-    _start_dc_author = _start_author
-    _start_dc_creator = _start_author
-    _start_itunes_author = _start_author
-
-    def _end_author(self):
-        self.pop('author')
-        self.inauthor = 0
-        self._sync_author_detail()
-    _end_managingeditor = _end_author
-    _end_dc_author = _end_author
-    _end_dc_creator = _end_author
-    _end_itunes_author = _end_author
-
-    def _start_itunes_owner(self, attrsD):
-        self.inpublisher = 1
-        self.push('publisher', 0)
-
-    def _end_itunes_owner(self):
-        self.pop('publisher')
-        self.inpublisher = 0
-        self._sync_author_detail('publisher')
-
-    def _start_contributor(self, attrsD):
-        self.incontributor = 1
-        context = self._getContext()
-        context.setdefault('contributors', [])
-        context['contributors'].append(FeedParserDict())
-        self.push('contributor', 0)
-
-    def _end_contributor(self):
-        self.pop('contributor')
-        self.incontributor = 0
-
-    def _start_dc_contributor(self, attrsD):
-        self.incontributor = 1
-        context = self._getContext()
-        context.setdefault('contributors', [])
-        context['contributors'].append(FeedParserDict())
-        self.push('name', 0)
-
-    def _end_dc_contributor(self):
-        self._end_name()
-        self.incontributor = 0
-
-    def _start_name(self, attrsD):
-        self.push('name', 0)
-    _start_itunes_name = _start_name
-
-    def _end_name(self):
-        value = self.pop('name')
-        if self.inpublisher:
-            self._save_author('name', value, 'publisher')
-        elif self.inauthor:
-            self._save_author('name', value)
-        elif self.incontributor:
-            self._save_contributor('name', value)
-        elif self.intextinput:
-            context = self._getContext()
-            context['name'] = value
-    _end_itunes_name = _end_name
-
-    def _start_width(self, attrsD):
-        self.push('width', 0)
-
-    def _end_width(self):
-        value = self.pop('width')
-        try:
-            value = int(value)
-        except:
-            value = 0
-        if self.inimage:
-            context = self._getContext()
-            context['width'] = value
-
-    def _start_height(self, attrsD):
-        self.push('height', 0)
-
-    def _end_height(self):
-        value = self.pop('height')
-        try:
-            value = int(value)
-        except:
-            value = 0
-        if self.inimage:
-            context = self._getContext()
-            context['height'] = value
-
-    def _start_url(self, attrsD):
-        self.push('href', 1)
-    _start_homepage = _start_url
-    _start_uri = _start_url
-
-    def _end_url(self):
-        value = self.pop('href')
-        if self.inauthor:
-            self._save_author('href', value)
-        elif self.incontributor:
-            self._save_contributor('href', value)
-    _end_homepage = _end_url
-    _end_uri = _end_url
-
-    def _start_email(self, attrsD):
-        self.push('email', 0)
-    _start_itunes_email = _start_email
-
-    def _end_email(self):
-        value = self.pop('email')
-        if self.inpublisher:
-            self._save_author('email', value, 'publisher')
-        elif self.inauthor:
-            self._save_author('email', value)
-        elif self.incontributor:
-            self._save_contributor('email', value)
-    _end_itunes_email = _end_email
-
-    def _getContext(self):
-        if self.insource:
-            context = self.sourcedata
-        elif self.inimage and self.feeddata.has_key('image'):
-            context = self.feeddata['image']
-        elif self.intextinput:
-            context = self.feeddata['textinput']
-        elif self.inentry:
-            context = self.entries[-1]
-        else:
-            context = self.feeddata
-        return context
-
-    def _save_author(self, key, value, prefix='author'):
-        context = self._getContext()
-        context.setdefault(prefix + '_detail', FeedParserDict())
-        context[prefix + '_detail'][key] = value
-        self._sync_author_detail()
-        context.setdefault('authors', [FeedParserDict()])
-        context['authors'][-1][key] = value
-
-    def _save_contributor(self, key, value):
-        context = self._getContext()
-        context.setdefault('contributors', [FeedParserDict()])
-        context['contributors'][-1][key] = value
-
-    def _sync_author_detail(self, key='author'):
-        context = self._getContext()
-        detail = context.get('%s_detail' % key)
-        if detail:
-            name = detail.get('name')
-            email = detail.get('email')
-            if name and email:
-                context[key] = '%s (%s)' % (name, email)
-            elif name:
-                context[key] = name
-            elif email:
-                context[key] = email
-        else:
-            author, email = context.get(key), None
-            if not author: return
-            emailmatch = re.search(r'''(([a-zA-Z0-9\_\-\.\+]+)@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([a-zA-Z0-9\-]+\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?))(\?subject=\S+)?''', author)
-            if emailmatch:
-                email = emailmatch.group(0)
-                # probably a better way to do the following, but it passes all the tests
-                author = author.replace(email, '')
-                author = author.replace('()', '')
-                author = author.replace('<>', '')
-                author = author.replace('&lt;&gt;', '')
-                author = author.strip()
-                if author and (author[0] == '('):
-                    author = author[1:]
-                if author and (author[-1] == ')'):
-                    author = author[:-1]
-                author = author.strip()
-            if author or email:
-                context.setdefault('%s_detail' % key, FeedParserDict())
-            if author:
-                context['%s_detail' % key]['name'] = author
-            if email:
-                context['%s_detail' % key]['email'] = email
-
-    def _start_subtitle(self, attrsD):
-        self.pushContent('subtitle', attrsD, 'text/plain', 1)
-    _start_tagline = _start_subtitle
-    _start_itunes_subtitle = _start_subtitle
-
-    def _end_subtitle(self):
-        self.popContent('subtitle')
-    _end_tagline = _end_subtitle
-    _end_itunes_subtitle = _end_subtitle
-            
-    def _start_rights(self, attrsD):
-        self.pushContent('rights', attrsD, 'text/plain', 1)
-    _start_dc_rights = _start_rights
-    _start_copyright = _start_rights
-
-    def _end_rights(self):
-        self.popContent('rights')
-    _end_dc_rights = _end_rights
-    _end_copyright = _end_rights
-
-    def _start_item(self, attrsD):
-        self.entries.append(FeedParserDict())
-        self.push('item', 0)
-        self.inentry = 1
-        self.guidislink = 0
-        self.hasTitle = 0
-        id = self._getAttribute(attrsD, 'rdf:about')
-        if id:
-            context = self._getContext()
-            context['id'] = id
-        self._cdf_common(attrsD)
-    _start_entry = _start_item
-    _start_product = _start_item
-
-    def _end_item(self):
-        self.pop('item')
-        self.inentry = 0
-    _end_entry = _end_item
-
-    def _start_dc_language(self, attrsD):
-        self.push('language', 1)
-    _start_language = _start_dc_language
-
-    def _end_dc_language(self):
-        self.lang = self.pop('language')
-    _end_language = _end_dc_language
-
-    def _start_dc_publisher(self, attrsD):
-        self.push('publisher', 1)
-    _start_webmaster = _start_dc_publisher
-
-    def _end_dc_publisher(self):
-        self.pop('publisher')
-        self._sync_author_detail('publisher')
-    _end_webmaster = _end_dc_publisher
-
-    def _start_published(self, attrsD):
-        self.push('published', 1)
-    _start_dcterms_issued = _start_published
-    _start_issued = _start_published
-
-    def _end_published(self):
-        value = self.pop('published')
-        self._save('published_parsed', _parse_date(value), overwrite=True)
-    _end_dcterms_issued = _end_published
-    _end_issued = _end_published
-
-    def _start_updated(self, attrsD):
-        self.push('updated', 1)
-    _start_modified = _start_updated
-    _start_dcterms_modified = _start_updated
-    _start_pubdate = _start_updated
-    _start_dc_date = _start_updated
-    _start_lastbuilddate = _start_updated
-
-    def _end_updated(self):
-        value = self.pop('updated')
-        parsed_value = _parse_date(value)
-        self._save('updated_parsed', parsed_value, overwrite=True)
-    _end_modified = _end_updated
-    _end_dcterms_modified = _end_updated
-    _end_pubdate = _end_updated
-    _end_dc_date = _end_updated
-    _end_lastbuilddate = _end_updated
-
-    def _start_created(self, attrsD):
-        self.push('created', 1)
-    _start_dcterms_created = _start_created
-
-    def _end_created(self):
-        value = self.pop('created')
-        self._save('created_parsed', _parse_date(value), overwrite=True)
-    _end_dcterms_created = _end_created
-
-    def _start_expirationdate(self, attrsD):
-        self.push('expired', 1)
-
-    def _end_expirationdate(self):
-        self._save('expired_parsed', _parse_date(self.pop('expired')), overwrite=True)
-
-    def _start_cc_license(self, attrsD):
-        context = self._getContext()
-        value = self._getAttribute(attrsD, 'rdf:resource')
-        attrsD = FeedParserDict()
-        attrsD['rel']='license'
-        if value: attrsD['href']=value
-        context.setdefault('links', []).append(attrsD)
-        
-    def _start_creativecommons_license(self, attrsD):
-        self.push('license', 1)
-    _start_creativeCommons_license = _start_creativecommons_license
-
-    def _end_creativecommons_license(self):
-        value = self.pop('license')
-        context = self._getContext()
-        attrsD = FeedParserDict()
-        attrsD['rel']='license'
-        if value: attrsD['href']=value
-        context.setdefault('links', []).append(attrsD)
-        del context['license']
-    _end_creativeCommons_license = _end_creativecommons_license
-
-    def _addXFN(self, relationships, href, name):
-        context = self._getContext()
-        xfn = context.setdefault('xfn', [])
-        value = FeedParserDict({'relationships': relationships, 'href': href, 'name': name})
-        if value not in xfn:
-            xfn.append(value)
-        
-    def _addTag(self, term, scheme, label):
-        context = self._getContext()
-        tags = context.setdefault('tags', [])
-        if (not term) and (not scheme) and (not label): return
-        value = FeedParserDict({'term': term, 'scheme': scheme, 'label': label})
-        if value not in tags:
-            tags.append(value)
-
-    def _start_category(self, attrsD):
-        if _debug: sys.stderr.write('entering _start_category with %s\n' % repr(attrsD))
-        term = attrsD.get('term')
-        scheme = attrsD.get('scheme', attrsD.get('domain'))
-        label = attrsD.get('label')
-        self._addTag(term, scheme, label)
-        self.push('category', 1)
-    _start_dc_subject = _start_category
-    _start_keywords = _start_category
-        
-    def _start_media_category(self, attrsD):
-        attrsD.setdefault('scheme', 'http://search.yahoo.com/mrss/category_schema')
-        self._start_category(attrsD)
-
-    def _end_itunes_keywords(self):
-        for term in self.pop('itunes_keywords').split():
-            self._addTag(term, 'http://www.itunes.com/', None)
-        
-    def _start_itunes_category(self, attrsD):
-        self._addTag(attrsD.get('text'), 'http://www.itunes.com/', None)
-        self.push('category', 1)
-        
-    def _end_category(self):
-        value = self.pop('category')
-        if not value: return
-        context = self._getContext()
-        tags = context['tags']
-        if value and len(tags) and not tags[-1]['term']:
-            tags[-1]['term'] = value
-        else:
-            self._addTag(value, None, None)
-    _end_dc_subject = _end_category
-    _end_keywords = _end_category
-    _end_itunes_category = _end_category
-    _end_media_category = _end_category
-
-    def _start_cloud(self, attrsD):
-        self._getContext()['cloud'] = FeedParserDict(attrsD)
-        
-    def _start_link(self, attrsD):
-        attrsD.setdefault('rel', 'alternate')
-        if attrsD['rel'] == 'self':
-            attrsD.setdefault('type', 'application/atom+xml')
-        else:
-            attrsD.setdefault('type', 'text/html')
-        context = self._getContext()
-        attrsD = self._itsAnHrefDamnIt(attrsD)
-        if attrsD.has_key('href'):
-            attrsD['href'] = self.resolveURI(attrsD['href'])
-        expectingText = self.infeed or self.inentry or self.insource
-        context.setdefault('links', [])
-        if not (self.inentry and self.inimage):
-            context['links'].append(FeedParserDict(attrsD))
-        if attrsD.has_key('href'):
-            expectingText = 0
-            if (attrsD.get('rel') == 'alternate') and (self.mapContentType(attrsD.get('type')) in self.html_types):
-                context['link'] = attrsD['href']
-        else:
-            self.push('link', expectingText)
-    _start_producturl = _start_link
-
-    def _end_link(self):
-        value = self.pop('link')
-        context = self._getContext()
-    _end_producturl = _end_link
-
-    def _start_guid(self, attrsD):
-        self.guidislink = (attrsD.get('ispermalink', 'true') == 'true')
-        self.push('id', 1)
-
-    def _end_guid(self):
-        value = self.pop('id')
-        self._save('guidislink', self.guidislink and not self._getContext().has_key('link'))
-        if self.guidislink:
-            # guid acts as link, but only if 'ispermalink' is not present or is 'true',
-            # and only if the item doesn't already have a link element
-            self._save('link', value)
-
-    def _start_title(self, attrsD):
-        if self.svgOK: return self.unknown_starttag('title', attrsD.items())
-        self.pushContent('title', attrsD, 'text/plain', self.infeed or self.inentry or self.insource)
-    _start_dc_title = _start_title
-    _start_media_title = _start_title
-
-    def _end_title(self):
-        if self.svgOK: return
-        value = self.popContent('title')
-        if not value: return
-        context = self._getContext()
-        self.hasTitle = 1
-    _end_dc_title = _end_title
-
-    def _end_media_title(self):
-        hasTitle = self.hasTitle
-        self._end_title()
-        self.hasTitle = hasTitle
-
-    def _start_description(self, attrsD):
-        context = self._getContext()
-        if context.has_key('summary'):
-            self._summaryKey = 'content'
-            self._start_content(attrsD)
-        else:
-            self.pushContent('description', attrsD, 'text/html', self.infeed or self.inentry or self.insource)
-    _start_dc_description = _start_description
-
-    def _start_abstract(self, attrsD):
-        self.pushContent('description', attrsD, 'text/plain', self.infeed or self.inentry or self.insource)
-
-    def _end_description(self):
-        if self._summaryKey == 'content':
-            self._end_content()
-        else:
-            value = self.popContent('description')
-        self._summaryKey = None
-    _end_abstract = _end_description
-    _end_dc_description = _end_description
-
-    def _start_info(self, attrsD):
-        self.pushContent('info', attrsD, 'text/plain', 1)
-    _start_feedburner_browserfriendly = _start_info
-
-    def _end_info(self):
-        self.popContent('info')
-    _end_feedburner_browserfriendly = _end_info
-
-    def _start_generator(self, attrsD):
-        if attrsD:
-            attrsD = self._itsAnHrefDamnIt(attrsD)
-            if attrsD.has_key('href'):
-                attrsD['href'] = self.resolveURI(attrsD['href'])
-        self._getContext()['generator_detail'] = FeedParserDict(attrsD)
-        self.push('generator', 1)
-
-    def _end_generator(self):
-        value = self.pop('generator')
-        context = self._getContext()
-        if context.has_key('generator_detail'):
-            context['generator_detail']['name'] = value
-            
-    def _start_admin_generatoragent(self, attrsD):
-        self.push('generator', 1)
-        value = self._getAttribute(attrsD, 'rdf:resource')
-        if value:
-            self.elementstack[-1][2].append(value)
-        self.pop('generator')
-        self._getContext()['generator_detail'] = FeedParserDict({'href': value})
-
-    def _start_admin_errorreportsto(self, attrsD):
-        self.push('errorreportsto', 1)
-        value = self._getAttribute(attrsD, 'rdf:resource')
-        if value:
-            self.elementstack[-1][2].append(value)
-        self.pop('errorreportsto')
-        
-    def _start_summary(self, attrsD):
-        context = self._getContext()
-        if context.has_key('summary'):
-            self._summaryKey = 'content'
-            self._start_content(attrsD)
-        else:
-            self._summaryKey = 'summary'
-            self.pushContent(self._summaryKey, attrsD, 'text/plain', 1)
-    _start_itunes_summary = _start_summary
-
-    def _end_summary(self):
-        if self._summaryKey == 'content':
-            self._end_content()
-        else:
-            self.popContent(self._summaryKey or 'summary')
-        self._summaryKey = None
-    _end_itunes_summary = _end_summary
-        
-    def _start_enclosure(self, attrsD):
-        attrsD = self._itsAnHrefDamnIt(attrsD)
-        context = self._getContext()
-        attrsD['rel']='enclosure'
-        context.setdefault('links', []).append(FeedParserDict(attrsD))
-            
-    def _start_source(self, attrsD):
-        if 'url' in attrsD:
-          # This means that we're processing a source element from an RSS 2.0 feed
-          self.sourcedata['href'] = attrsD[u'url']
-        self.push('source', 1)
-        self.insource = 1
-        self.hasTitle = 0
-
-    def _end_source(self):
-        self.insource = 0
-        value = self.pop('source')
-        if value:
-          self.sourcedata['title'] = value
-        self._getContext()['source'] = copy.deepcopy(self.sourcedata)
-        self.sourcedata.clear()
-
-    def _start_content(self, attrsD):
-        self.pushContent('content', attrsD, 'text/plain', 1)
-        src = attrsD.get('src')
-        if src:
-            self.contentparams['src'] = src
-        self.push('content', 1)
-
-    def _start_prodlink(self, attrsD):
-        self.pushContent('content', attrsD, 'text/html', 1)
-
-    def _start_body(self, attrsD):
-        self.pushContent('content', attrsD, 'application/xhtml+xml', 1)
-    _start_xhtml_body = _start_body
-
-    def _start_content_encoded(self, attrsD):
-        self.pushContent('content', attrsD, 'text/html', 1)
-    _start_fullitem = _start_content_encoded
-
-    def _end_content(self):
-        copyToSummary = self.mapContentType(self.contentparams.get('type')) in (['text/plain'] + self.html_types)
-        value = self.popContent('content')
-        if copyToSummary:
-            self._save('summary', value)
-
-    _end_body = _end_content
-    _end_xhtml_body = _end_content
-    _end_content_encoded = _end_content
-    _end_fullitem = _end_content
-    _end_prodlink = _end_content
-
-    def _start_itunes_image(self, attrsD):
-        self.push('itunes_image', 0)
-        if attrsD.get('href'):
-            self._getContext()['image'] = FeedParserDict({'href': attrsD.get('href')})
-    _start_itunes_link = _start_itunes_image
-        
-    def _end_itunes_block(self):
-        value = self.pop('itunes_block', 0)
-        self._getContext()['itunes_block'] = (value == 'yes') and 1 or 0
-
-    def _end_itunes_explicit(self):
-        value = self.pop('itunes_explicit', 0)
-        # Convert 'yes' -> True, 'clean' to False, and any other value to None
-        # False and None both evaluate as False, so the difference can be ignored
-        # by applications that only need to know if the content is explicit.
-        self._getContext()['itunes_explicit'] = (None, False, True)[(value == 'yes' and 2) or value == 'clean' or 0]
-
-    def _start_media_content(self, attrsD):
-        context = self._getContext()
-        context.setdefault('media_content', [])
-        context['media_content'].append(attrsD)
-
-    def _start_media_thumbnail(self, attrsD):
-        context = self._getContext()
-        context.setdefault('media_thumbnail', [])
-        self.push('url', 1) # new
-        context['media_thumbnail'].append(attrsD)
-
-    def _end_media_thumbnail(self):
-        url = self.pop('url')
-        context = self._getContext()
-        if url is not None and len(url.strip()) != 0:
-            if not context['media_thumbnail'][-1].has_key('url'):
-                context['media_thumbnail'][-1]['url'] = url
-
-    def _start_media_player(self, attrsD):
-        self.push('media_player', 0)
-        self._getContext()['media_player'] = FeedParserDict(attrsD)
-
-    def _end_media_player(self):
-        value = self.pop('media_player')
-        context = self._getContext()
-        context['media_player']['content'] = value
-
-    def _start_newlocation(self, attrsD):
-        self.push('newlocation', 1)
-
-    def _end_newlocation(self):
-        url = self.pop('newlocation')
-        context = self._getContext()
-        # don't set newlocation if the context isn't right
-        if context is not self.feeddata:
-            return
-        context['newlocation'] = _makeSafeAbsoluteURI(self.baseuri, url.strip())
-
-if _XML_AVAILABLE:
-    class _StrictFeedParser(_FeedParserMixin, xml.sax.handler.ContentHandler):
-        def __init__(self, baseuri, baselang, encoding):
-            if _debug: sys.stderr.write('trying StrictFeedParser\n')
-            xml.sax.handler.ContentHandler.__init__(self)
-            _FeedParserMixin.__init__(self, baseuri, baselang, encoding)
-            self.bozo = 0
-            self.exc = None
-            self.decls = {}
-        
-        def startPrefixMapping(self, prefix, uri):
-            self.trackNamespace(prefix, uri)
-            if uri == 'http://www.w3.org/1999/xlink':
-              self.decls['xmlns:'+prefix] = uri
-        
-        def startElementNS(self, name, qname, attrs):
-            namespace, localname = name
-            lowernamespace = str(namespace or '').lower()
-            if lowernamespace.find('backend.userland.com/rss') <> -1:
-                # match any backend.userland.com namespace
-                namespace = 'http://backend.userland.com/rss'
-                lowernamespace = namespace
-            if qname and qname.find(':') > 0:
-                givenprefix = qname.split(':')[0]
-            else:
-                givenprefix = None
-            prefix = self._matchnamespaces.get(lowernamespace, givenprefix)
-            if givenprefix and (prefix is None or (prefix == '' and lowernamespace == '')) and not self.namespacesInUse.has_key(givenprefix):
-                    raise UndeclaredNamespace, "'%s' is not associated with a namespace" % givenprefix
-            localname = str(localname).lower()
-
-            # qname implementation is horribly broken in Python 2.1 (it
-            # doesn't report any), and slightly broken in Python 2.2 (it
-            # doesn't report the xml: namespace). So we match up namespaces
-            # with a known list first, and then possibly override them with
-            # the qnames the SAX parser gives us (if indeed it gives us any
-            # at all).  Thanks to MatejC for helping me test this and
-            # tirelessly telling me that it didn't work yet.
-            attrsD, self.decls = self.decls, {}
-            if localname=='math' and namespace=='http://www.w3.org/1998/Math/MathML':
-                attrsD['xmlns']=namespace
-            if localname=='svg' and namespace=='http://www.w3.org/2000/svg':
-                attrsD['xmlns']=namespace
-
-            if prefix:
-                localname = prefix.lower() + ':' + localname
-            elif namespace and not qname: #Expat
-                for name,value in self.namespacesInUse.items():
-                     if name and value == namespace:
-                         localname = name + ':' + localname
-                         break
-            if _debug: sys.stderr.write('startElementNS: qname = %s, namespace = %s, givenprefix = %s, prefix = %s, attrs = %s, localname = %s\n' % (qname, namespace, givenprefix, prefix, attrs.items(), localname))
-
-            for (namespace, attrlocalname), attrvalue in attrs._attrs.items():
-                lowernamespace = (namespace or '').lower()
-                prefix = self._matchnamespaces.get(lowernamespace, '')
-                if prefix:
-                    attrlocalname = prefix + ':' + attrlocalname
-                attrsD[str(attrlocalname).lower()] = attrvalue
-            for qname in attrs.getQNames():
-                attrsD[str(qname).lower()] = attrs.getValueByQName(qname)
-            self.unknown_starttag(localname, attrsD.items())
-
-        def characters(self, text):
-            self.handle_data(text)
-
-        def endElementNS(self, name, qname):
-            namespace, localname = name
-            lowernamespace = str(namespace or '').lower()
-            if qname and qname.find(':') > 0:
-                givenprefix = qname.split(':')[0]
-            else:
-                givenprefix = ''
-            prefix = self._matchnamespaces.get(lowernamespace, givenprefix)
-            if prefix:
-                localname = prefix + ':' + localname
-            elif namespace and not qname: #Expat
-                for name,value in self.namespacesInUse.items():
-                     if name and value == namespace:
-                         localname = name + ':' + localname
-                         break
-            localname = str(localname).lower()
-            self.unknown_endtag(localname)
-
-        def error(self, exc):
-            self.bozo = 1
-            self.exc = exc
-
-        def fatalError(self, exc):
-            self.error(exc)
-            raise exc
-
-class _BaseHTMLProcessor(sgmllib.SGMLParser):
-    special = re.compile('''[<>'"]''')
-    bare_ampersand = re.compile("&(?!#\d+;|#x[0-9a-fA-F]+;|\w+;)")
-    elements_no_end_tag = [
-      'area', 'base', 'basefont', 'br', 'col', 'command', 'embed', 'frame', 
-      'hr', 'img', 'input', 'isindex', 'keygen', 'link', 'meta', 'param',
-      'source', 'track', 'wbr'
-    ]
-
-    def __init__(self, encoding, _type):
-        self.encoding = encoding
-        self._type = _type
-        if _debug: sys.stderr.write('entering BaseHTMLProcessor, encoding=%s\n' % self.encoding)
-        sgmllib.SGMLParser.__init__(self)
-
-    def reset(self):
-        self.pieces = []
-        sgmllib.SGMLParser.reset(self)
-
-    def _shorttag_replace(self, match):
-        tag = match.group(1)
-        if tag in self.elements_no_end_tag:
-            return '<' + tag + ' />'
-        else:
-            return '<' + tag + '></' + tag + '>'
-
-    def parse_starttag(self,i):
-        j=sgmllib.SGMLParser.parse_starttag(self, i)
-        if self._type == 'application/xhtml+xml':
-            if j>2 and self.rawdata[j-2:j]=='/>':
-                self.unknown_endtag(self.lasttag)
-        return j
-
-    def feed(self, data):
-        data = re.compile(r'<!((?!DOCTYPE|--|\[))', re.IGNORECASE).sub(r'&lt;!\1', data)
-        #data = re.sub(r'<(\S+?)\s*?/>', self._shorttag_replace, data) # bug [ 1399464 ] Bad regexp for _shorttag_replace
-        data = re.sub(r'<([^<>\s]+?)\s*/>', self._shorttag_replace, data) 
-        data = data.replace('&#39;', "'")
-        data = data.replace('&#34;', '"')
-        try:
-            bytes
-            if bytes is str:
-                raise NameError
-            self.encoding = self.encoding + '_INVALID_PYTHON_3'
-        except NameError:
-            if self.encoding and type(data) == type(u''):
-                data = data.encode(self.encoding)
-        sgmllib.SGMLParser.feed(self, data)
-        sgmllib.SGMLParser.close(self)
-
-    def normalize_attrs(self, attrs):
-        if not attrs: return attrs
-        # utility method to be called by descendants
-        attrs = dict([(k.lower(), v) for k, v in attrs]).items()
-        attrs = [(k, k in ('rel', 'type') and v.lower() or v) for k, v in attrs]
-        attrs.sort()
-        return attrs
-
-    def unknown_starttag(self, tag, attrs):
-        # called for each start tag
-        # attrs is a list of (attr, value) tuples
-        # e.g. for <pre class='screen'>, tag='pre', attrs=[('class', 'screen')]
-        if _debug: sys.stderr.write('_BaseHTMLProcessor, unknown_starttag, tag=%s\n' % tag)
-        uattrs = []
-        strattrs=''
-        if attrs:
-            for key, value in attrs:
-                value=value.replace('>','&gt;').replace('<','&lt;').replace('"','&quot;')
-                value = self.bare_ampersand.sub("&amp;", value)
-                # thanks to Kevin Marks for this breathtaking hack to deal with (valid) high-bit attribute values in UTF-8 feeds
-                if type(value) != type(u''):
-                    try:
-                        value = unicode(value, self.encoding)
-                    except:
-                        value = unicode(value, 'iso-8859-1')
-                try:
-                    # Currently, in Python 3 the key is already a str, and cannot be decoded again
-                    uattrs.append((unicode(key, self.encoding), value))
-                except TypeError:
-                    uattrs.append((key, value))
-            strattrs = u''.join([u' %s="%s"' % (key, value) for key, value in uattrs])
-            if self.encoding:
-                try:
-                    strattrs=strattrs.encode(self.encoding)
-                except:
-                    pass
-        if tag in self.elements_no_end_tag:
-            self.pieces.append('<%(tag)s%(strattrs)s />' % locals())
-        else:
-            self.pieces.append('<%(tag)s%(strattrs)s>' % locals())
-
-    def unknown_endtag(self, tag):
-        # called for each end tag, e.g. for </pre>, tag will be 'pre'
-        # Reconstruct the original end tag.
-        if tag not in self.elements_no_end_tag:
-            self.pieces.append("</%(tag)s>" % locals())
-
-    def handle_charref(self, ref):
-        # called for each character reference, e.g. for '&#160;', ref will be '160'
-        # Reconstruct the original character reference.
-        if ref.startswith('x'):
-            value = unichr(int(ref[1:],16))
-        else:
-            value = unichr(int(ref))
-
-        if value in _cp1252.keys():
-            self.pieces.append('&#%s;' % hex(ord(_cp1252[value]))[1:])
-        else:
-            self.pieces.append('&#%(ref)s;' % locals())
-        
-    def handle_entityref(self, ref):
-        # called for each entity reference, e.g. for '&copy;', ref will be 'copy'
-        # Reconstruct the original entity reference.
-        if name2codepoint.has_key(ref):
-            self.pieces.append('&%(ref)s;' % locals())
-        else:
-            self.pieces.append('&amp;%(ref)s' % locals())
-
-    def handle_data(self, text):
-        # called for each block of plain text, i.e. outside of any tag and
-        # not containing any character or entity references
-        # Store the original text verbatim.
-        if _debug: sys.stderr.write('_BaseHTMLProcessor, handle_data, text=%s\n' % text)
-        self.pieces.append(text)
-        
-    def handle_comment(self, text):
-        # called for each HTML comment, e.g. <!-- insert Javascript code here -->
-        # Reconstruct the original comment.
-        self.pieces.append('<!--%(text)s-->' % locals())
-        
-    def handle_pi(self, text):
-        # called for each processing instruction, e.g. <?instruction>
-        # Reconstruct original processing instruction.
-        self.pieces.append('<?%(text)s>' % locals())
-
-    def handle_decl(self, text):
-        # called for the DOCTYPE, if present, e.g.
-        # <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
-        #     "http://www.w3.org/TR/html4/loose.dtd">
-        # Reconstruct original DOCTYPE
-        self.pieces.append('<!%(text)s>' % locals())
-        
-    _new_declname_match = re.compile(r'[a-zA-Z][-_.a-zA-Z0-9:]*\s*').match
-    def _scan_name(self, i, declstartpos):
-        rawdata = self.rawdata
-        n = len(rawdata)
-        if i == n:
-            return None, -1
-        m = self._new_declname_match(rawdata, i)
-        if m:
-            s = m.group()
-            name = s.strip()
-            if (i + len(s)) == n:
-                return None, -1  # end of buffer
-            return name.lower(), m.end()
-        else:
-            self.handle_data(rawdata)
-#            self.updatepos(declstartpos, i)
-            return None, -1
-
-    def convert_charref(self, name):
-        return '&#%s;' % name
-
-    def convert_entityref(self, name):
-        return '&%s;' % name
-
-    def output(self):
-        '''Return processed HTML as a single string'''
-        return ''.join([str(p) for p in self.pieces])
-
-class _LooseFeedParser(_FeedParserMixin, _BaseHTMLProcessor):
-    def __init__(self, baseuri, baselang, encoding, entities):
-        sgmllib.SGMLParser.__init__(self)
-        _FeedParserMixin.__init__(self, baseuri, baselang, encoding)
-        _BaseHTMLProcessor.__init__(self, encoding, 'application/xhtml+xml')
-        self.entities=entities
-
-    def decodeEntities(self, element, data):
-        data = data.replace('&#60;', '&lt;')
-        data = data.replace('&#x3c;', '&lt;')
-        data = data.replace('&#x3C;', '&lt;')
-        data = data.replace('&#62;', '&gt;')
-        data = data.replace('&#x3e;', '&gt;')
-        data = data.replace('&#x3E;', '&gt;')
-        data = data.replace('&#38;', '&amp;')
-        data = data.replace('&#x26;', '&amp;')
-        data = data.replace('&#34;', '&quot;')
-        data = data.replace('&#x22;', '&quot;')
-        data = data.replace('&#39;', '&apos;')
-        data = data.replace('&#x27;', '&apos;')
-        if self.contentparams.has_key('type') and not self.contentparams.get('type', 'xml').endswith('xml'):
-            data = data.replace('&lt;', '<')
-            data = data.replace('&gt;', '>')
-            data = data.replace('&amp;', '&')
-            data = data.replace('&quot;', '"')
-            data = data.replace('&apos;', "'")
-        return data
-        
-    def strattrs(self, attrs):
-        return ''.join([' %s="%s"' % (n,v.replace('"','&quot;')) for n,v in attrs])
-
-class _MicroformatsParser:
-    STRING = 1
-    DATE = 2
-    URI = 3
-    NODE = 4
-    EMAIL = 5
-
-    known_xfn_relationships = ['contact', 'acquaintance', 'friend', 'met', 'co-worker', 'coworker', 'colleague', 'co-resident', 'coresident', 'neighbor', 'child', 'parent', 'sibling', 'brother', 'sister', 'spouse', 'wife', 'husband', 'kin', 'relative', 'muse', 'crush', 'date', 'sweetheart', 'me']
-    known_binary_extensions =  ['zip','rar','exe','gz','tar','tgz','tbz2','bz2','z','7z','dmg','img','sit','sitx','hqx','deb','rpm','bz2','jar','rar','iso','bin','msi','mp2','mp3','ogg','ogm','mp4','m4v','m4a','avi','wma','wmv']
-
-    def __init__(self, data, baseuri, encoding):
-        self.document = BeautifulSoup.BeautifulSoup(data)
-        self.baseuri = baseuri
-        self.encoding = encoding
-        if type(data) == type(u''):
-            data = data.encode(encoding)
-        self.tags = []
-        self.enclosures = []
-        self.xfn = []
-        self.vcard = None
-    
-    def vcardEscape(self, s):
-        if type(s) in (type(''), type(u'')):
-            s = s.replace(',', '\\,').replace(';', '\\;').replace('\n', '\\n')
-        return s
-    
-    def vcardFold(self, s):
-        s = re.sub(';+$', '', s)
-        sFolded = ''
-        iMax = 75
-        sPrefix = ''
-        while len(s) > iMax:
-            sFolded += sPrefix + s[:iMax] + '\n'
-            s = s[iMax:]
-            sPrefix = ' '
-            iMax = 74
-        sFolded += sPrefix + s
-        return sFolded
-
-    def normalize(self, s):
-        return re.sub(r'\s+', ' ', s).strip()
-    
-    def unique(self, aList):
-        results = []
-        for element in aList:
-            if element not in results:
-                results.append(element)
-        return results
-    
-    def toISO8601(self, dt):
-        return time.strftime('%Y-%m-%dT%H:%M:%SZ', dt)
-
-    def getPropertyValue(self, elmRoot, sProperty, iPropertyType=4, bAllowMultiple=0, bAutoEscape=0):
-        all = lambda x: 1
-        sProperty = sProperty.lower()
-        bFound = 0
-        bNormalize = 1
-        propertyMatch = {'class': re.compile(r'\b%s\b' % sProperty)}
-        if bAllowMultiple and (iPropertyType != self.NODE):
-            snapResults = []
-            containers = elmRoot(['ul', 'ol'], propertyMatch)
-            for container in containers:
-                snapResults.extend(container('li'))
-            bFound = (len(snapResults) != 0)
-        if not bFound:
-            snapResults = elmRoot(all, propertyMatch)
-            bFound = (len(snapResults) != 0)
-        if (not bFound) and (sProperty == 'value'):
-            snapResults = elmRoot('pre')
-            bFound = (len(snapResults) != 0)
-            bNormalize = not bFound
-            if not bFound:
-                snapResults = [elmRoot]
-                bFound = (len(snapResults) != 0)
-        arFilter = []
-        if sProperty == 'vcard':
-            snapFilter = elmRoot(all, propertyMatch)
-            for node in snapFilter:
-                if node.findParent(all, propertyMatch):
-                    arFilter.append(node)
-        arResults = []
-        for node in snapResults:
-            if node not in arFilter:
-                arResults.append(node)
-        bFound = (len(arResults) != 0)
-        if not bFound:
-            if bAllowMultiple: return []
-            elif iPropertyType == self.STRING: return ''
-            elif iPropertyType == self.DATE: return None
-            elif iPropertyType == self.URI: return ''
-            elif iPropertyType == self.NODE: return None
-            else: return None
-        arValues = []
-        for elmResult in arResults:
-            sValue = None
-            if iPropertyType == self.NODE:
-                if bAllowMultiple:
-                    arValues.append(elmResult)
-                    continue
-                else:
-                    return elmResult
-            sNodeName = elmResult.name.lower()
-            if (iPropertyType == self.EMAIL) and (sNodeName == 'a'):
-                sValue = (elmResult.get('href') or '').split('mailto:').pop().split('?')[0]
-            if sValue:
-                sValue = bNormalize and self.normalize(sValue) or sValue.strip()
-            if (not sValue) and (sNodeName == 'abbr'):
-                sValue = elmResult.get('title')
-            if sValue:
-                sValue = bNormalize and self.normalize(sValue) or sValue.strip()
-            if (not sValue) and (iPropertyType == self.URI):
-                if sNodeName == 'a': sValue = elmResult.get('href')
-                elif sNodeName == 'img': sValue = elmResult.get('src')
-                elif sNodeName == 'object': sValue = elmResult.get('data')
-            if sValue:
-                sValue = bNormalize and self.normalize(sValue) or sValue.strip()
-            if (not sValue) and (sNodeName == 'img'):
-                sValue = elmResult.get('alt')
-            if sValue:
-                sValue = bNormalize and self.normalize(sValue) or sValue.strip()
-            if not sValue:
-                sValue = elmResult.renderContents()
-                sValue = re.sub(r'<\S[^>]*>', '', sValue)
-                sValue = sValue.replace('\r\n', '\n')
-                sValue = sValue.replace('\r', '\n')
-            if sValue:
-                sValue = bNormalize and self.normalize(sValue) or sValue.strip()
-            if not sValue: continue
-            if iPropertyType == self.DATE:
-                sValue = _parse_date_iso8601(sValue)
-            if bAllowMultiple:
-                arValues.append(bAutoEscape and self.vcardEscape(sValue) or sValue)
-            else:
-                return bAutoEscape and self.vcardEscape(sValue) or sValue
-        return arValues
-
-    def findVCards(self, elmRoot, bAgentParsing=0):
-        sVCards = ''
-        
-        if not bAgentParsing:
-            arCards = self.getPropertyValue(elmRoot, 'vcard', bAllowMultiple=1)
-        else:
-            arCards = [elmRoot]
-            
-        for elmCard in arCards:
-            arLines = []
-            
-            def processSingleString(sProperty):
-                sValue = self.getPropertyValue(elmCard, sProperty, self.STRING, bAutoEscape=1).decode(self.encoding)
-                if sValue:
-                    arLines.append(self.vcardFold(sProperty.upper() + ':' + sValue))
-                return sValue or u''
-            
-            def processSingleURI(sProperty):
-                sValue = self.getPropertyValue(elmCard, sProperty, self.URI)
-                if sValue:
-                    sContentType = ''
-                    sEncoding = ''
-                    sValueKey = ''
-                    if sValue.startswith('data:'):
-                        sEncoding = ';ENCODING=b'
-                        sContentType = sValue.split(';')[0].split('/').pop()
-                        sValue = sValue.split(',', 1).pop()
-                    else:
-                        elmValue = self.getPropertyValue(elmCard, sProperty)
-                        if elmValue:
-                            if sProperty != 'url':
-                                sValueKey = ';VALUE=uri'
-                            sContentType = elmValue.get('type', '').strip().split('/').pop().strip()
-                    sContentType = sContentType.upper()
-                    if sContentType == 'OCTET-STREAM':
-                        sContentType = ''
-                    if sContentType:
-                        sContentType = ';TYPE=' + sContentType.upper()
-                    arLines.append(self.vcardFold(sProperty.upper() + sEncoding + sContentType + sValueKey + ':' + sValue))
-    
-            def processTypeValue(sProperty, arDefaultType, arForceType=None):
-                arResults = self.getPropertyValue(elmCard, sProperty, bAllowMultiple=1)
-                for elmResult in arResults:
-                    arType = self.getPropertyValue(elmResult, 'type', self.STRING, 1, 1)
-                    if arForceType:
-                        arType = self.unique(arForceType + arType)
-                    if not arType:
-                        arType = arDefaultType
-                    sValue = self.getPropertyValue(elmResult, 'value', self.EMAIL, 0)
-                    if sValue:
-                        arLines.append(self.vcardFold(sProperty.upper() + ';TYPE=' + ','.join(arType) + ':' + sValue))
-            
-            # AGENT
-            # must do this before all other properties because it is destructive
-            # (removes nested class="vcard" nodes so they don't interfere with
-            # this vcard's other properties)
-            arAgent = self.getPropertyValue(elmCard, 'agent', bAllowMultiple=1)
-            for elmAgent in arAgent:
-                if re.compile(r'\bvcard\b').search(elmAgent.get('class')):
-                    sAgentValue = self.findVCards(elmAgent, 1) + '\n'
-                    sAgentValue = sAgentValue.replace('\n', '\\n')
-                    sAgentValue = sAgentValue.replace(';', '\\;')
-                    if sAgentValue:
-                        arLines.append(self.vcardFold('AGENT:' + sAgentValue))
-                    # Completely remove the agent element from the parse tree
-                    elmAgent.extract()
-                else:
-                    sAgentValue = self.getPropertyValue(elmAgent, 'value', self.URI, bAutoEscape=1);
-                    if sAgentValue:
-                        arLines.append(self.vcardFold('AGENT;VALUE=uri:' + sAgentValue))
-    
-            # FN (full name)
-            sFN = processSingleString('fn')
-            
-            # N (name)
-            elmName = self.getPropertyValue(elmCard, 'n')
-            if elmName:
-                sFamilyName = self.getPropertyValue(elmName, 'family-name', self.STRING, bAutoEscape=1)
-                sGivenName = self.getPropertyValue(elmName, 'given-name', self.STRING, bAutoEscape=1)
-                arAdditionalNames = self.getPropertyValue(elmName, 'additional-name', self.STRING, 1, 1) + self.getPropertyValue(elmName, 'additional-names', self.STRING, 1, 1)
-                arHonorificPrefixes = self.getPropertyValue(elmName, 'honorific-prefix', self.STRING, 1, 1) + self.getPropertyValue(elmName, 'honorific-prefixes', self.STRING, 1, 1)
-                arHonorificSuffixes = self.getPropertyValue(elmName, 'honorific-suffix', self.STRING, 1, 1) + self.getPropertyValue(elmName, 'honorific-suffixes', self.STRING, 1, 1)
-                arLines.append(self.vcardFold('N:' + sFamilyName + ';' + 
-                                         sGivenName + ';' +
-                                         ','.join(arAdditionalNames) + ';' +
-                                         ','.join(arHonorificPrefixes) + ';' +
-                                         ','.join(arHonorificSuffixes)))
-            elif sFN:
-                # implied "N" optimization
-                # http://microformats.org/wiki/hcard#Implied_.22N.22_Optimization
-                arNames = self.normalize(sFN).split()
-                if len(arNames) == 2:
-                    bFamilyNameFirst = (arNames[0].endswith(',') or
-                                        len(arNames[1]) == 1 or
-                                        ((len(arNames[1]) == 2) and (arNames[1].endswith('.'))))
-                    if bFamilyNameFirst:
-                        arLines.append(self.vcardFold('N:' + arNames[0] + ';' + arNames[1]))
-                    else:
-                        arLines.append(self.vcardFold('N:' + arNames[1] + ';' + arNames[0]))
-    
-            # SORT-STRING
-            sSortString = self.getPropertyValue(elmCard, 'sort-string', self.STRING, bAutoEscape=1)
-            if sSortString:
-                arLines.append(self.vcardFold('SORT-STRING:' + sSortString))
-            
-            # NICKNAME
-            arNickname = self.getPropertyValue(elmCard, 'nickname', self.STRING, 1, 1)
-            if arNickname:
-                arLines.append(self.vcardFold('NICKNAME:' + ','.join(arNickname)))
-            
-            # PHOTO
-            processSingleURI('photo')
-            
-            # BDAY
-            dtBday = self.getPropertyValue(elmCard, 'bday', self.DATE)
-            if dtBday:
-                arLines.append(self.vcardFold('BDAY:' + self.toISO8601(dtBday)))
-            
-            # ADR (address)
-            arAdr = self.getPropertyValue(elmCard, 'adr', bAllowMultiple=1)
-            for elmAdr in arAdr:
-                arType = self.getPropertyValue(elmAdr, 'type', self.STRING, 1, 1)
-                if not arType:
-                    arType = ['intl','postal','parcel','work'] # default adr types, see RFC 2426 section 3.2.1
-                sPostOfficeBox = self.getPropertyValue(elmAdr, 'post-office-box', self.STRING, 0, 1)
-                sExtendedAddress = self.getPropertyValue(elmAdr, 'extended-address', self.STRING, 0, 1)
-                sStreetAddress = self.getPropertyValue(elmAdr, 'street-address', self.STRING, 0, 1)
-                sLocality = self.getPropertyValue(elmAdr, 'locality', self.STRING, 0, 1)
-                sRegion = self.getPropertyValue(elmAdr, 'region', self.STRING, 0, 1)
-                sPostalCode = self.getPropertyValue(elmAdr, 'postal-code', self.STRING, 0, 1)
-                sCountryName = self.getPropertyValue(elmAdr, 'country-name', self.STRING, 0, 1)
-                arLines.append(self.vcardFold('ADR;TYPE=' + ','.join(arType) + ':' +
-                                         sPostOfficeBox + ';' +
-                                         sExtendedAddress + ';' +
-                                         sStreetAddress + ';' +
-                                         sLocality + ';' +
-                                         sRegion + ';' +
-                                         sPostalCode + ';' +
-                                         sCountryName))
-            
-            # LABEL
-            processTypeValue('label', ['intl','postal','parcel','work'])
-            
-            # TEL (phone number)
-            processTypeValue('tel', ['voice'])
-            
-            # EMAIL
-            processTypeValue('email', ['internet'], ['internet'])
-            
-            # MAILER
-            processSingleString('mailer')
-            
-            # TZ (timezone)
-            processSingleString('tz')
-    
-            # GEO (geographical information)
-            elmGeo = self.getPropertyValue(elmCard, 'geo')
-            if elmGeo:
-                sLatitude = self.getPropertyValue(elmGeo, 'latitude', self.STRING, 0, 1)
-                sLongitude = self.getPropertyValue(elmGeo, 'longitude', self.STRING, 0, 1)
-                arLines.append(self.vcardFold('GEO:' + sLatitude + ';' + sLongitude))
-    
-            # TITLE
-            processSingleString('title')
-    
-            # ROLE
-            processSingleString('role')
-
-            # LOGO
-            processSingleURI('logo')
-    
-            # ORG (organization)
-            elmOrg = self.getPropertyValue(elmCard, 'org')
-            if elmOrg:
-                sOrganizationName = self.getPropertyValue(elmOrg, 'organization-name', self.STRING, 0, 1)
-                if not sOrganizationName:
-                    # implied "organization-name" optimization
-                    # http://microformats.org/wiki/hcard#Implied_.22organization-name.22_Optimization
-                    sOrganizationName = self.getPropertyValue(elmCard, 'org', self.STRING, 0, 1)
-                    if sOrganizationName:
-                        arLines.append(self.vcardFold('ORG:' + sOrganizationName))
-                else:
-                    arOrganizationUnit = self.getPropertyValue(elmOrg, 'organization-unit', self.STRING, 1, 1)
-                    arLines.append(self.vcardFold('ORG:' + sOrganizationName + ';' + ';'.join(arOrganizationUnit)))
-    
-            # CATEGORY
-            arCategory = self.getPropertyValue(elmCard, 'category', self.STRING, 1, 1) + self.getPropertyValue(elmCard, 'categories', self.STRING, 1, 1)
-            if arCategory:
-                arLines.append(self.vcardFold('CATEGORIES:' + ','.join(arCategory)))
-    
-            # NOTE
-            processSingleString('note')
-    
-            # REV
-            processSingleString('rev')
-    
-            # SOUND
-            processSingleURI('sound')
-    
-            # UID
-            processSingleString('uid')
-    
-            # URL
-            processSingleURI('url')
-    
-            # CLASS
-            processSingleString('class')
-    
-            # KEY
-            processSingleURI('key')
-    
-            if arLines:
-                arLines = [u'BEGIN:vCard',u'VERSION:3.0'] + arLines + [u'END:vCard']
-                sVCards += u'\n'.join(arLines) + u'\n'
-    
-        return sVCards.strip()
-    
-    def isProbablyDownloadable(self, elm):
-        attrsD = elm.attrMap
-        if not attrsD.has_key('href'): return 0
-        linktype = attrsD.get('type', '').strip()
-        if linktype.startswith('audio/') or \
-           linktype.startswith('video/') or \
-           (linktype.startswith('application/') and not linktype.endswith('xml')):
-            return 1
-        path = urlparse.urlparse(attrsD['href'])[2]
-        if path.find('.') == -1: return 0
-        fileext = path.split('.').pop().lower()
-        return fileext in self.known_binary_extensions
-
-    def findTags(self):
-        all = lambda x: 1
-        for elm in self.document(all, {'rel': re.compile(r'\btag\b')}):
-            href = elm.get('href')
-            if not href: continue
-            urlscheme, domain, path, params, query, fragment = \
-                       urlparse.urlparse(_urljoin(self.baseuri, href))
-            segments = path.split('/')
-            tag = segments.pop()
-            if not tag:
-                tag = segments.pop()
-            tagscheme = urlparse.urlunparse((urlscheme, domain, '/'.join(segments), '', '', ''))
-            if not tagscheme.endswith('/'):
-                tagscheme += '/'
-            self.tags.append(FeedParserDict({"term": tag, "scheme": tagscheme, "label": elm.string or ''}))
-
-    def findEnclosures(self):
-        all = lambda x: 1
-        enclosure_match = re.compile(r'\benclosure\b')
-        for elm in self.document(all, {'href': re.compile(r'.+')}):
-            if not enclosure_match.search(elm.get('rel', '')) and not self.isProbablyDownloadable(elm): continue
-            if elm.attrMap not in self.enclosures:
-                self.enclosures.append(elm.attrMap)
-                if elm.string and not elm.get('title'):
-                    self.enclosures[-1]['title'] = elm.string
-
-    def findXFN(self):
-        all = lambda x: 1
-        for elm in self.document(all, {'rel': re.compile('.+'), 'href': re.compile('.+')}):
-            rels = elm.get('rel', '').split()
-            xfn_rels = []
-            for rel in rels:
-                if rel in self.known_xfn_relationships:
-                    xfn_rels.append(rel)
-            if xfn_rels:
-                self.xfn.append({"relationships": xfn_rels, "href": elm.get('href', ''), "name": elm.string})
-
-def _parseMicroformats(htmlSource, baseURI, encoding):
-    if not BeautifulSoup: return
-    if _debug: sys.stderr.write('entering _parseMicroformats\n')
-    try:
-        p = _MicroformatsParser(htmlSource, baseURI, encoding)
-    except UnicodeEncodeError:
-        # sgmllib throws this exception when performing lookups of tags
-        # with non-ASCII characters in them.
-        return
-    p.vcard = p.findVCards(p.document)
-    p.findTags()
-    p.findEnclosures()
-    p.findXFN()
-    return {"tags": p.tags, "enclosures": p.enclosures, "xfn": p.xfn, "vcard": p.vcard}
-
-class _RelativeURIResolver(_BaseHTMLProcessor):
-    relative_uris = [('a', 'href'),
-                     ('applet', 'codebase'),
-                     ('area', 'href'),
-                     ('blockquote', 'cite'),
-                     ('body', 'background'),
-                     ('del', 'cite'),
-                     ('form', 'action'),
-                     ('frame', 'longdesc'),
-                     ('frame', 'src'),
-                     ('iframe', 'longdesc'),
-                     ('iframe', 'src'),
-                     ('head', 'profile'),
-                     ('img', 'longdesc'),
-                     ('img', 'src'),
-                     ('img', 'usemap'),
-                     ('input', 'src'),
-                     ('input', 'usemap'),
-                     ('ins', 'cite'),
-                     ('link', 'href'),
-                     ('object', 'classid'),
-                     ('object', 'codebase'),
-                     ('object', 'data'),
-                     ('object', 'usemap'),
-                     ('q', 'cite'),
-                     ('script', 'src')]
-
-    def __init__(self, baseuri, encoding, _type):
-        _BaseHTMLProcessor.__init__(self, encoding, _type)
-        self.baseuri = baseuri
-
-    def resolveURI(self, uri):
-        return _makeSafeAbsoluteURI(_urljoin(self.baseuri, uri.strip()))
-    
-    def unknown_starttag(self, tag, attrs):
-        if _debug:
-            sys.stderr.write('tag: [%s] with attributes: [%s]\n' % (tag, str(attrs)))
-        attrs = self.normalize_attrs(attrs)
-        attrs = [(key, ((tag, key) in self.relative_uris) and self.resolveURI(value) or value) for key, value in attrs]
-        _BaseHTMLProcessor.unknown_starttag(self, tag, attrs)
-
-def _resolveRelativeURIs(htmlSource, baseURI, encoding, _type):
-    if _debug:
-        sys.stderr.write('entering _resolveRelativeURIs\n')
-
-    p = _RelativeURIResolver(baseURI, encoding, _type)
-    p.feed(htmlSource)
-    return p.output()
-
-def _makeSafeAbsoluteURI(base, rel=None):
-    # bail if ACCEPTABLE_URI_SCHEMES is empty
-    if not ACCEPTABLE_URI_SCHEMES:
-        return _urljoin(base, rel or u'')
-    if not base:
-        return rel or u''
-    if not rel:
-        if base.strip().split(':', 1)[0] not in ACCEPTABLE_URI_SCHEMES:
-            return u''
-        return base
-    uri = _urljoin(base, rel)
-    if uri.strip().split(':', 1)[0] not in ACCEPTABLE_URI_SCHEMES:
-        return u''
-    return uri
-
-class _HTMLSanitizer(_BaseHTMLProcessor):
-    acceptable_elements = ['a', 'abbr', 'acronym', 'address', 'area',
-        'article', 'aside', 'audio', 'b', 'big', 'blockquote', 'br', 'button',
-        'canvas', 'caption', 'center', 'cite', 'code', 'col', 'colgroup',
-        'command', 'datagrid', 'datalist', 'dd', 'del', 'details', 'dfn',
-        'dialog', 'dir', 'div', 'dl', 'dt', 'em', 'event-source', 'fieldset',
-        'figcaption', 'figure', 'footer', 'font', 'form', 'header', 'h1',
-        'h2', 'h3', 'h4', 'h5', 'h6', 'hr', 'i', 'img', 'input', 'ins',
-        'keygen', 'kbd', 'label', 'legend', 'li', 'm', 'map', 'menu', 'meter',
-        'multicol', 'nav', 'nextid', 'ol', 'output', 'optgroup', 'option',
-        'p', 'pre', 'progress', 'q', 's', 'samp', 'section', 'select',
-        'small', 'sound', 'source', 'spacer', 'span', 'strike', 'strong',
-        'sub', 'sup', 'table', 'tbody', 'td', 'textarea', 'time', 'tfoot',
-        'th', 'thead', 'tr', 'tt', 'u', 'ul', 'var', 'video', 'noscript']
-
-    acceptable_attributes = ['abbr', 'accept', 'accept-charset', 'accesskey',
-      'action', 'align', 'alt', 'autocomplete', 'autofocus', 'axis',
-      'background', 'balance', 'bgcolor', 'bgproperties', 'border',
-      'bordercolor', 'bordercolordark', 'bordercolorlight', 'bottompadding',
-      'cellpadding', 'cellspacing', 'ch', 'challenge', 'char', 'charoff',
-      'choff', 'charset', 'checked', 'cite', 'class', 'clear', 'color', 'cols',
-      'colspan', 'compact', 'contenteditable', 'controls', 'coords', 'data',
-      'datafld', 'datapagesize', 'datasrc', 'datetime', 'default', 'delay',
-      'dir', 'disabled', 'draggable', 'dynsrc', 'enctype', 'end', 'face', 'for',
-      'form', 'frame', 'galleryimg', 'gutter', 'headers', 'height', 'hidefocus',
-      'hidden', 'high', 'href', 'hreflang', 'hspace', 'icon', 'id', 'inputmode',
-      'ismap', 'keytype', 'label', 'leftspacing', 'lang', 'list', 'longdesc',
-      'loop', 'loopcount', 'loopend', 'loopstart', 'low', 'lowsrc', 'max',
-      'maxlength', 'media', 'method', 'min', 'multiple', 'name', 'nohref',
-      'noshade', 'nowrap', 'open', 'optimum', 'pattern', 'ping', 'point-size',
-      'prompt', 'pqg', 'radiogroup', 'readonly', 'rel', 'repeat-max',
-      'repeat-min', 'replace', 'required', 'rev', 'rightspacing', 'rows',
-      'rowspan', 'rules', 'scope', 'selected', 'shape', 'size', 'span', 'src',
-      'start', 'step', 'summary', 'suppress', 'tabindex', 'target', 'template',
-      'title', 'toppadding', 'type', 'unselectable', 'usemap', 'urn', 'valign',
-      'value', 'variable', 'volume', 'vspace', 'vrml', 'width', 'wrap',
-      'xml:lang']
-
-    unacceptable_elements_with_end_tag = ['script', 'applet', 'style']
-
-    acceptable_css_properties = ['azimuth', 'background-color',
-      'border-bottom-color', 'border-collapse', 'border-color',
-      'border-left-color', 'border-right-color', 'border-top-color', 'clear',
-      'color', 'cursor', 'direction', 'display', 'elevation', 'float', 'font',
-      'font-family', 'font-size', 'font-style', 'font-variant', 'font-weight',
-      'height', 'letter-spacing', 'line-height', 'overflow', 'pause',
-      'pause-after', 'pause-before', 'pitch', 'pitch-range', 'richness',
-      'speak', 'speak-header', 'speak-numeral', 'speak-punctuation',
-      'speech-rate', 'stress', 'text-align', 'text-decoration', 'text-indent',
-      'unicode-bidi', 'vertical-align', 'voice-family', 'volume',
-      'white-space', 'width']
-
-    # survey of common keywords found in feeds
-    acceptable_css_keywords = ['auto', 'aqua', 'black', 'block', 'blue',
-      'bold', 'both', 'bottom', 'brown', 'center', 'collapse', 'dashed',
-      'dotted', 'fuchsia', 'gray', 'green', '!important', 'italic', 'left',
-      'lime', 'maroon', 'medium', 'none', 'navy', 'normal', 'nowrap', 'olive',
-      'pointer', 'purple', 'red', 'right', 'solid', 'silver', 'teal', 'top',
-      'transparent', 'underline', 'white', 'yellow']
-
-    valid_css_values = re.compile('^(#[0-9a-f]+|rgb\(\d+%?,\d*%?,?\d*%?\)?|' +
-      '\d{0,2}\.?\d{0,2}(cm|em|ex|in|mm|pc|pt|px|%|,|\))?)$')
-
-    mathml_elements = ['annotation', 'annotation-xml', 'maction', 'math',
-      'merror', 'mfenced', 'mfrac', 'mi', 'mmultiscripts', 'mn', 'mo', 'mover', 'mpadded',
-      'mphantom', 'mprescripts', 'mroot', 'mrow', 'mspace', 'msqrt', 'mstyle',
-      'msub', 'msubsup', 'msup', 'mtable', 'mtd', 'mtext', 'mtr', 'munder',
-      'munderover', 'none', 'semantics']
-
-    mathml_attributes = ['actiontype', 'align', 'columnalign', 'columnalign',
-      'columnalign', 'close', 'columnlines', 'columnspacing', 'columnspan', 'depth',
-      'display', 'displaystyle', 'encoding', 'equalcolumns', 'equalrows',
-      'fence', 'fontstyle', 'fontweight', 'frame', 'height', 'linethickness',
-      'lspace', 'mathbackground', 'mathcolor', 'mathvariant', 'mathvariant',
-      'maxsize', 'minsize', 'open', 'other', 'rowalign', 'rowalign', 'rowalign',
-      'rowlines', 'rowspacing', 'rowspan', 'rspace', 'scriptlevel', 'selection',
-      'separator', 'separators', 'stretchy', 'width', 'width', 'xlink:href',
-      'xlink:show', 'xlink:type', 'xmlns', 'xmlns:xlink']
-
-    # svgtiny - foreignObject + linearGradient + radialGradient + stop
-    svg_elements = ['a', 'animate', 'animateColor', 'animateMotion',
-      'animateTransform', 'circle', 'defs', 'desc', 'ellipse', 'foreignObject',
-      'font-face', 'font-face-name', 'font-face-src', 'g', 'glyph', 'hkern', 
-      'linearGradient', 'line', 'marker', 'metadata', 'missing-glyph', 'mpath',
-      'path', 'polygon', 'polyline', 'radialGradient', 'rect', 'set', 'stop',
-      'svg', 'switch', 'text', 'title', 'tspan', 'use']
-
-    # svgtiny + class + opacity + offset + xmlns + xmlns:xlink
-    svg_attributes = ['accent-height', 'accumulate', 'additive', 'alphabetic',
-       'arabic-form', 'ascent', 'attributeName', 'attributeType',
-       'baseProfile', 'bbox', 'begin', 'by', 'calcMode', 'cap-height',
-       'class', 'color', 'color-rendering', 'content', 'cx', 'cy', 'd', 'dx',
-       'dy', 'descent', 'display', 'dur', 'end', 'fill', 'fill-opacity',
-       'fill-rule', 'font-family', 'font-size', 'font-stretch', 'font-style',
-       'font-variant', 'font-weight', 'from', 'fx', 'fy', 'g1', 'g2',
-       'glyph-name', 'gradientUnits', 'hanging', 'height', 'horiz-adv-x',
-       'horiz-origin-x', 'id', 'ideographic', 'k', 'keyPoints', 'keySplines',
-       'keyTimes', 'lang', 'mathematical', 'marker-end', 'marker-mid',
-       'marker-start', 'markerHeight', 'markerUnits', 'markerWidth', 'max',
-       'min', 'name', 'offset', 'opacity', 'orient', 'origin',
-       'overline-position', 'overline-thickness', 'panose-1', 'path',
-       'pathLength', 'points', 'preserveAspectRatio', 'r', 'refX', 'refY',
-       'repeatCount', 'repeatDur', 'requiredExtensions', 'requiredFeatures',
-       'restart', 'rotate', 'rx', 'ry', 'slope', 'stemh', 'stemv',
-       'stop-color', 'stop-opacity', 'strikethrough-position',
-       'strikethrough-thickness', 'stroke', 'stroke-dasharray',
-       'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin',
-       'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'systemLanguage',
-       'target', 'text-anchor', 'to', 'transform', 'type', 'u1', 'u2',
-       'underline-position', 'underline-thickness', 'unicode', 'unicode-range',
-       'units-per-em', 'values', 'version', 'viewBox', 'visibility', 'width',
-       'widths', 'x', 'x-height', 'x1', 'x2', 'xlink:actuate', 'xlink:arcrole',
-       'xlink:href', 'xlink:role', 'xlink:show', 'xlink:title', 'xlink:type',
-       'xml:base', 'xml:lang', 'xml:space', 'xmlns', 'xmlns:xlink', 'y', 'y1',
-       'y2', 'zoomAndPan']
-
-    svg_attr_map = None
-    svg_elem_map = None
-
-    acceptable_svg_properties = [ 'fill', 'fill-opacity', 'fill-rule',
-      'stroke', 'stroke-width', 'stroke-linecap', 'stroke-linejoin',
-      'stroke-opacity']
-
-    def reset(self):
-        _BaseHTMLProcessor.reset(self)
-        self.unacceptablestack = 0
-        self.mathmlOK = 0
-        self.svgOK = 0
-        
-    def unknown_starttag(self, tag, attrs):
-        acceptable_attributes = self.acceptable_attributes
-        keymap = {}
-        if not tag in self.acceptable_elements or self.svgOK:
-            if tag in self.unacceptable_elements_with_end_tag:
-                self.unacceptablestack += 1
-
-            # add implicit namespaces to html5 inline svg/mathml
-            if self._type.endswith('html'):
-                if not dict(attrs).get('xmlns'):
-                    if tag=='svg':
-                        attrs.append( ('xmlns','http://www.w3.org/2000/svg') )
-                    if tag=='math':
-                        attrs.append( ('xmlns','http://www.w3.org/1998/Math/MathML') )
-
-            # not otherwise acceptable, perhaps it is MathML or SVG?
-            if tag=='math' and ('xmlns','http://www.w3.org/1998/Math/MathML') in attrs:
-                self.mathmlOK += 1
-            if tag=='svg' and ('xmlns','http://www.w3.org/2000/svg') in attrs:
-                self.svgOK += 1
-
-            # chose acceptable attributes based on tag class, else bail
-            if  self.mathmlOK and tag in self.mathml_elements:
-                acceptable_attributes = self.mathml_attributes
-            elif self.svgOK and tag in self.svg_elements:
-                # for most vocabularies, lowercasing is a good idea.  Many
-                # svg elements, however, are camel case
-                if not self.svg_attr_map:
-                    lower=[attr.lower() for attr in self.svg_attributes]
-                    mix=[a for a in self.svg_attributes if a not in lower]
-                    self.svg_attributes = lower
-                    self.svg_attr_map = dict([(a.lower(),a) for a in mix])
-
-                    lower=[attr.lower() for attr in self.svg_elements]
-                    mix=[a for a in self.svg_elements if a not in lower]
-                    self.svg_elements = lower
-                    self.svg_elem_map = dict([(a.lower(),a) for a in mix])
-                acceptable_attributes = self.svg_attributes
-                tag = self.svg_elem_map.get(tag,tag)
-                keymap = self.svg_attr_map
-            elif not tag in self.acceptable_elements:
-                return
-
-        # declare xlink namespace, if needed
-        if self.mathmlOK or self.svgOK:
-            if filter(lambda (n,v): n.startswith('xlink:'),attrs):
-                if not ('xmlns:xlink','http://www.w3.org/1999/xlink') in attrs:
-                    attrs.append(('xmlns:xlink','http://www.w3.org/1999/xlink'))
-
-        clean_attrs = []
-        for key, value in self.normalize_attrs(attrs):
-            if key in acceptable_attributes:
-                key=keymap.get(key,key)
-                clean_attrs.append((key,value))
-            elif key=='style':
-                clean_value = self.sanitize_style(value)
-                if clean_value: clean_attrs.append((key,clean_value))
-        _BaseHTMLProcessor.unknown_starttag(self, tag, clean_attrs)
-        
-    def unknown_endtag(self, tag):
-        if not tag in self.acceptable_elements:
-            if tag in self.unacceptable_elements_with_end_tag:
-                self.unacceptablestack -= 1
-            if self.mathmlOK and tag in self.mathml_elements:
-                if tag == 'math' and self.mathmlOK: self.mathmlOK -= 1
-            elif self.svgOK and tag in self.svg_elements:
-                tag = self.svg_elem_map.get(tag,tag)
-                if tag == 'svg' and self.svgOK: self.svgOK -= 1
-            else:
-                return
-        _BaseHTMLProcessor.unknown_endtag(self, tag)
-
-    def handle_pi(self, text):
-        pass
-
-    def handle_decl(self, text):
-        pass
-
-    def handle_data(self, text):
-        if not self.unacceptablestack:
-            _BaseHTMLProcessor.handle_data(self, text)
-
-    def sanitize_style(self, style):
-        # disallow urls
-        style=re.compile('url\s*\(\s*[^\s)]+?\s*\)\s*').sub(' ',style)
-
-        # gauntlet
-        if not re.match("""^([:,;#%.\sa-zA-Z0-9!]|\w-\w|'[\s\w]+'|"[\s\w]+"|\([\d,\s]+\))*$""", style): return ''
-        # This replaced a regexp that used re.match and was prone to pathological back-tracking.
-        if re.sub("\s*[-\w]+\s*:\s*[^:;]*;?", '', style).strip(): return ''
-
-        clean = []
-        for prop,value in re.findall("([-\w]+)\s*:\s*([^:;]*)",style):
-          if not value: continue
-          if prop.lower() in self.acceptable_css_properties:
-              clean.append(prop + ': ' + value + ';')
-          elif prop.split('-')[0].lower() in ['background','border','margin','padding']:
-              for keyword in value.split():
-                  if not keyword in self.acceptable_css_keywords and \
-                      not self.valid_css_values.match(keyword):
-                      break
-              else:
-                  clean.append(prop + ': ' + value + ';')
-          elif self.svgOK and prop.lower() in self.acceptable_svg_properties:
-              clean.append(prop + ': ' + value + ';')
-
-        return ' '.join(clean)
-
-
-def _sanitizeHTML(htmlSource, encoding, _type):
-    p = _HTMLSanitizer(encoding, _type)
-    htmlSource = htmlSource.replace('<![CDATA[', '&lt;![CDATA[')
-    p.feed(htmlSource)
-    data = p.output()
-    if TIDY_MARKUP:
-        # loop through list of preferred Tidy interfaces looking for one that's installed,
-        # then set up a common _tidy function to wrap the interface-specific API.
-        _tidy = None
-        for tidy_interface in PREFERRED_TIDY_INTERFACES:
-            try:
-                if tidy_interface == "uTidy":
-                    from tidy import parseString as _utidy
-                    def _tidy(data, **kwargs):
-                        return str(_utidy(data, **kwargs))
-                    break
-                elif tidy_interface == "mxTidy":
-                    from mx.Tidy import Tidy as _mxtidy
-                    def _tidy(data, **kwargs):
-                        nerrors, nwarnings, data, errordata = _mxtidy.tidy(data, **kwargs)
-                        return data
-                    break
-            except:
-                pass
-        if _tidy:
-            utf8 = type(data) == type(u'')
-            if utf8:
-                data = data.encode('utf-8')
-            data = _tidy(data, output_xhtml=1, numeric_entities=1, wrap=0, char_encoding="utf8")
-            if utf8:
-                data = unicode(data, 'utf-8')
-            if data.count('<body'):
-                data = data.split('<body', 1)[1]
-                if data.count('>'):
-                    data = data.split('>', 1)[1]
-            if data.count('</body'):
-                data = data.split('</body', 1)[0]
-    data = data.strip().replace('\r\n', '\n')
-    return data
-
-class _FeedURLHandler(urllib2.HTTPDigestAuthHandler, urllib2.HTTPRedirectHandler, urllib2.HTTPDefaultErrorHandler):
-    def http_error_default(self, req, fp, code, msg, headers):
-        if ((code / 100) == 3) and (code != 304):
-            return self.http_error_302(req, fp, code, msg, headers)
-        infourl = urllib.addinfourl(fp, headers, req.get_full_url())
-        infourl.status = code
-        return infourl
-
-    def http_error_302(self, req, fp, code, msg, headers):
-        if headers.dict.has_key('location'):
-            infourl = urllib2.HTTPRedirectHandler.http_error_302(self, req, fp, code, msg, headers)
-        else:
-            infourl = urllib.addinfourl(fp, headers, req.get_full_url())
-        if not hasattr(infourl, 'status'):
-            infourl.status = code
-        return infourl
-
-    def http_error_301(self, req, fp, code, msg, headers):
-        if headers.dict.has_key('location'):
-            infourl = urllib2.HTTPRedirectHandler.http_error_301(self, req, fp, code, msg, headers)
-        else:
-            infourl = urllib.addinfourl(fp, headers, req.get_full_url())
-        if not hasattr(infourl, 'status'):
-            infourl.status = code
-        return infourl
-
-    http_error_300 = http_error_302
-    http_error_303 = http_error_302
-    http_error_307 = http_error_302
-        
-    def http_error_401(self, req, fp, code, msg, headers):
-        # Check if
-        # - server requires digest auth, AND
-        # - we tried (unsuccessfully) with basic auth, AND
-        # - we're using Python 2.3.3 or later (digest auth is irreparably broken in earlier versions)
-        # If all conditions hold, parse authentication information
-        # out of the Authorization header we sent the first time
-        # (for the username and password) and the WWW-Authenticate
-        # header the server sent back (for the realm) and retry
-        # the request with the appropriate digest auth headers instead.
-        # This evil genius hack has been brought to you by Aaron Swartz.
-        host = urlparse.urlparse(req.get_full_url())[1]
-        try:
-            assert sys.version.split()[0] >= '2.3.3'
-            assert base64 is not None
-            user, passw = _base64decode(req.headers['Authorization'].split(' ')[1]).split(':')
-            realm = re.findall('realm="([^"]*)"', headers['WWW-Authenticate'])[0]
-            self.add_password(realm, host, user, passw)
-            retry = self.http_error_auth_reqed('www-authenticate', host, req, headers)
-            self.reset_retry_count()
-            return retry
-        except:
-            return self.http_error_default(req, fp, code, msg, headers)
-
-def _open_resource(url_file_stream_or_string, etag, modified, agent, referrer, handlers, request_headers):
-    """URL, filename, or string --> stream
-
-    This function lets you define parsers that take any input source
-    (URL, pathname to local or network file, or actual data as a string)
-    and deal with it in a uniform manner.  Returned object is guaranteed
-    to have all the basic stdio read methods (read, readline, readlines).
-    Just .close() the object when you're done with it.
-
-    If the etag argument is supplied, it will be used as the value of an
-    If-None-Match request header.
-
-    If the modified argument is supplied, it can be a tuple of 9 integers
-    (as returned by gmtime() in the standard Python time module) or a date
-    string in any format supported by feedparser. Regardless, it MUST
-    be in GMT (Greenwich Mean Time). It will be reformatted into an
-    RFC 1123-compliant date and used as the value of an If-Modified-Since
-    request header.
-
-    If the agent argument is supplied, it will be used as the value of a
-    User-Agent request header.
-
-    If the referrer argument is supplied, it will be used as the value of a
-    Referer[sic] request header.
-
-    If handlers is supplied, it is a list of handlers used to build a
-    urllib2 opener.
-
-    if request_headers is supplied it is a dictionary of HTTP request headers
-    that will override the values generated by FeedParser.
-    """
-
-    if hasattr(url_file_stream_or_string, 'read'):
-        return url_file_stream_or_string
-
-    if url_file_stream_or_string == '-':
-        return sys.stdin
-
-    if urlparse.urlparse(url_file_stream_or_string)[0] in ('http', 'https', 'ftp', 'file', 'feed'):
-        # Deal with the feed URI scheme
-        if url_file_stream_or_string.startswith('feed:http'):
-            url_file_stream_or_string = url_file_stream_or_string[5:]
-        elif url_file_stream_or_string.startswith('feed:'):
-            url_file_stream_or_string = 'http:' + url_file_stream_or_string[5:]
-        if not agent:
-            agent = USER_AGENT
-        # test for inline user:password for basic auth
-        auth = None
-        if base64:
-            urltype, rest = urllib.splittype(url_file_stream_or_string)
-            realhost, rest = urllib.splithost(rest)
-            if realhost:
-                user_passwd, realhost = urllib.splituser(realhost)
-                if user_passwd:
-                    url_file_stream_or_string = '%s://%s%s' % (urltype, realhost, rest)
-                    auth = base64.standard_b64encode(user_passwd).strip()
-
-        # iri support
-        try:
-            if isinstance(url_file_stream_or_string,unicode):
-                url_file_stream_or_string = url_file_stream_or_string.encode('idna').decode('utf-8')
-            else:
-                url_file_stream_or_string = url_file_stream_or_string.decode('utf-8').encode('idna').decode('utf-8')
-        except:
-            pass
-
-        # try to open with urllib2 (to use optional headers)
-        request = _build_urllib2_request(url_file_stream_or_string, agent, etag, modified, referrer, auth, request_headers)
-        opener = apply(urllib2.build_opener, tuple(handlers + [_FeedURLHandler()]))
-        opener.addheaders = [] # RMK - must clear so we only send our custom User-Agent
-        try:
-            return opener.open(request)
-        finally:
-            opener.close() # JohnD
-    
-    # try to open with native open function (if url_file_stream_or_string is a filename)
-    try:
-        return open(url_file_stream_or_string, 'rb')
-    except:
-        pass
-
-    # treat url_file_stream_or_string as string
-    return _StringIO(str(url_file_stream_or_string))
-
-def _build_urllib2_request(url, agent, etag, modified, referrer, auth, request_headers):
-    request = urllib2.Request(url)
-    request.add_header('User-Agent', agent)
-    if etag:
-        request.add_header('If-None-Match', etag)
-    if type(modified) == type(''):
-        modified = _parse_date(modified)
-    elif isinstance(modified, datetime.datetime):
-        modified = modified.utctimetuple()
-    if modified:
-        # format into an RFC 1123-compliant timestamp. We can't use
-        # time.strftime() since the %a and %b directives can be affected
-        # by the current locale, but RFC 2616 states that dates must be
-        # in English.
-        short_weekdays = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
-        months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
-        request.add_header('If-Modified-Since', '%s, %02d %s %04d %02d:%02d:%02d GMT' % (short_weekdays[modified[6]], modified[2], months[modified[1] - 1], modified[0], modified[3], modified[4], modified[5]))
-    if referrer:
-        request.add_header('Referer', referrer)
-    if gzip and zlib:
-        request.add_header('Accept-encoding', 'gzip, deflate')
-    elif gzip:
-        request.add_header('Accept-encoding', 'gzip')
-    elif zlib:
-        request.add_header('Accept-encoding', 'deflate')
-    else:
-        request.add_header('Accept-encoding', '')
-    if auth:
-        request.add_header('Authorization', 'Basic %s' % auth)
-    if ACCEPT_HEADER:
-        request.add_header('Accept', ACCEPT_HEADER)
-    # use this for whatever -- cookies, special headers, etc
-    # [('Cookie','Something'),('x-special-header','Another Value')]
-    for header_name, header_value in request_headers.items():
-        request.add_header(header_name, header_value)
-    request.add_header('A-IM', 'feed') # RFC 3229 support
-    return request
-
-_date_handlers = []
-def registerDateHandler(func):
-    '''Register a date handler function (takes string, returns 9-tuple date in GMT)'''
-    _date_handlers.insert(0, func)
-    
-# ISO-8601 date parsing routines written by Fazal Majid.
-# The ISO 8601 standard is very convoluted and irregular - a full ISO 8601
-# parser is beyond the scope of feedparser and would be a worthwhile addition
-# to the Python library.
-# A single regular expression cannot parse ISO 8601 date formats into groups
-# as the standard is highly irregular (for instance is 030104 2003-01-04 or
-# 0301-04-01), so we use templates instead.
-# Please note the order in templates is significant because we need a
-# greedy match.
-_iso8601_tmpl = ['YYYY-?MM-?DD', 'YYYY-0MM?-?DD', 'YYYY-MM', 'YYYY-?OOO',
-                'YY-?MM-?DD', 'YY-?OOO', 'YYYY', 
-                '-YY-?MM', '-OOO', '-YY',
-                '--MM-?DD', '--MM',
-                '---DD',
-                'CC', '']
-_iso8601_re = [
-    tmpl.replace(
-    'YYYY', r'(?P<year>\d{4})').replace(
-    'YY', r'(?P<year>\d\d)').replace(
-    'MM', r'(?P<month>[01]\d)').replace(
-    'DD', r'(?P<day>[0123]\d)').replace(
-    'OOO', r'(?P<ordinal>[0123]\d\d)').replace(
-    'CC', r'(?P<century>\d\d$)')
-    + r'(T?(?P<hour>\d{2}):(?P<minute>\d{2})'
-    + r'(:(?P<second>\d{2}))?'
-    + r'(\.(?P<fracsecond>\d+))?'
-    + r'(?P<tz>[+-](?P<tzhour>\d{2})(:(?P<tzmin>\d{2}))?|Z)?)?'
-    for tmpl in _iso8601_tmpl]
-try:
-    del tmpl
-except NameError:
-    pass
-_iso8601_matches = [re.compile(regex).match for regex in _iso8601_re]
-try:
-    del regex
-except NameError:
-    pass
-def _parse_date_iso8601(dateString):
-    '''Parse a variety of ISO-8601-compatible formats like 20040105'''
-    m = None
-    for _iso8601_match in _iso8601_matches:
-        m = _iso8601_match(dateString)
-        if m: break
-    if not m: return
-    if m.span() == (0, 0): return
-    params = m.groupdict()
-    ordinal = params.get('ordinal', 0)
-    if ordinal:
-        ordinal = int(ordinal)
-    else:
-        ordinal = 0
-    year = params.get('year', '--')
-    if not year or year == '--':
-        year = time.gmtime()[0]
-    elif len(year) == 2:
-        # ISO 8601 assumes current century, i.e. 93 -> 2093, NOT 1993
-        year = 100 * int(time.gmtime()[0] / 100) + int(year)
-    else:
-        year = int(year)
-    month = params.get('month', '-')
-    if not month or month == '-':
-        # ordinals are NOT normalized by mktime, we simulate them
-        # by setting month=1, day=ordinal
-        if ordinal:
-            month = 1
-        else:
-            month = time.gmtime()[1]
-    month = int(month)
-    day = params.get('day', 0)
-    if not day:
-        # see above
-        if ordinal:
-            day = ordinal
-        elif params.get('century', 0) or \
-                 params.get('year', 0) or params.get('month', 0):
-            day = 1
-        else:
-            day = time.gmtime()[2]
-    else:
-        day = int(day)
-    # special case of the century - is the first year of the 21st century
-    # 2000 or 2001 ? The debate goes on...
-    if 'century' in params.keys():
-        year = (int(params['century']) - 1) * 100 + 1
-    # in ISO 8601 most fields are optional
-    for field in ['hour', 'minute', 'second', 'tzhour', 'tzmin']:
-        if not params.get(field, None):
-            params[field] = 0
-    hour = int(params.get('hour', 0))
-    minute = int(params.get('minute', 0))
-    second = int(float(params.get('second', 0)))
-    # weekday is normalized by mktime(), we can ignore it
-    weekday = 0
-    daylight_savings_flag = -1
-    tm = [year, month, day, hour, minute, second, weekday,
-          ordinal, daylight_savings_flag]
-    # ISO 8601 time zone adjustments
-    tz = params.get('tz')
-    if tz and tz != 'Z':
-        if tz[0] == '-':
-            tm[3] += int(params.get('tzhour', 0))
-            tm[4] += int(params.get('tzmin', 0))
-        elif tz[0] == '+':
-            tm[3] -= int(params.get('tzhour', 0))
-            tm[4] -= int(params.get('tzmin', 0))
-        else:
-            return None
-    # Python's time.mktime() is a wrapper around the ANSI C mktime(3c)
-    # which is guaranteed to normalize d/m/y/h/m/s.
-    # Many implementations have bugs, but we'll pretend they don't.
-    return time.localtime(time.mktime(tuple(tm)))
-registerDateHandler(_parse_date_iso8601)
-    
-# 8-bit date handling routines written by ytrewq1.
-_korean_year  = u'\ub144' # b3e2 in euc-kr
-_korean_month = u'\uc6d4' # bff9 in euc-kr
-_korean_day   = u'\uc77c' # c0cf in euc-kr
-_korean_am    = u'\uc624\uc804' # bfc0 c0fc in euc-kr
-_korean_pm    = u'\uc624\ud6c4' # bfc0 c8c4 in euc-kr
-
-_korean_onblog_date_re = \
-    re.compile('(\d{4})%s\s+(\d{2})%s\s+(\d{2})%s\s+(\d{2}):(\d{2}):(\d{2})' % \
-               (_korean_year, _korean_month, _korean_day))
-_korean_nate_date_re = \
-    re.compile(u'(\d{4})-(\d{2})-(\d{2})\s+(%s|%s)\s+(\d{,2}):(\d{,2}):(\d{,2})' % \
-               (_korean_am, _korean_pm))
-def _parse_date_onblog(dateString):
-    '''Parse a string according to the OnBlog 8-bit date format'''
-    m = _korean_onblog_date_re.match(dateString)
-    if not m: return
-    w3dtfdate = '%(year)s-%(month)s-%(day)sT%(hour)s:%(minute)s:%(second)s%(zonediff)s' % \
-                {'year': m.group(1), 'month': m.group(2), 'day': m.group(3),\
-                 'hour': m.group(4), 'minute': m.group(5), 'second': m.group(6),\
-                 'zonediff': '+09:00'}
-    if _debug: sys.stderr.write('OnBlog date parsed as: %s\n' % w3dtfdate)
-    return _parse_date_w3dtf(w3dtfdate)
-registerDateHandler(_parse_date_onblog)
-
-def _parse_date_nate(dateString):
-    '''Parse a string according to the Nate 8-bit date format'''
-    m = _korean_nate_date_re.match(dateString)
-    if not m: return
-    hour = int(m.group(5))
-    ampm = m.group(4)
-    if (ampm == _korean_pm):
-        hour += 12
-    hour = str(hour)
-    if len(hour) == 1:
-        hour = '0' + hour
-    w3dtfdate = '%(year)s-%(month)s-%(day)sT%(hour)s:%(minute)s:%(second)s%(zonediff)s' % \
-                {'year': m.group(1), 'month': m.group(2), 'day': m.group(3),\
-                 'hour': hour, 'minute': m.group(6), 'second': m.group(7),\
-                 'zonediff': '+09:00'}
-    if _debug: sys.stderr.write('Nate date parsed as: %s\n' % w3dtfdate)
-    return _parse_date_w3dtf(w3dtfdate)
-registerDateHandler(_parse_date_nate)
-
-_mssql_date_re = \
-    re.compile('(\d{4})-(\d{2})-(\d{2})\s+(\d{2}):(\d{2}):(\d{2})(\.\d+)?')
-def _parse_date_mssql(dateString):
-    '''Parse a string according to the MS SQL date format'''
-    m = _mssql_date_re.match(dateString)
-    if not m: return
-    w3dtfdate = '%(year)s-%(month)s-%(day)sT%(hour)s:%(minute)s:%(second)s%(zonediff)s' % \
-                {'year': m.group(1), 'month': m.group(2), 'day': m.group(3),\
-                 'hour': m.group(4), 'minute': m.group(5), 'second': m.group(6),\
-                 'zonediff': '+09:00'}
-    if _debug: sys.stderr.write('MS SQL date parsed as: %s\n' % w3dtfdate)
-    return _parse_date_w3dtf(w3dtfdate)
-registerDateHandler(_parse_date_mssql)
-
-# Unicode strings for Greek date strings
-_greek_months = \
-  { \
-   u'\u0399\u03b1\u03bd': u'Jan',       # c9e1ed in iso-8859-7
-   u'\u03a6\u03b5\u03b2': u'Feb',       # d6e5e2 in iso-8859-7
-   u'\u039c\u03ac\u03ce': u'Mar',       # ccdcfe in iso-8859-7
-   u'\u039c\u03b1\u03ce': u'Mar',       # cce1fe in iso-8859-7
-   u'\u0391\u03c0\u03c1': u'Apr',       # c1f0f1 in iso-8859-7
-   u'\u039c\u03ac\u03b9': u'May',       # ccdce9 in iso-8859-7
-   u'\u039c\u03b1\u03ca': u'May',       # cce1fa in iso-8859-7
-   u'\u039c\u03b1\u03b9': u'May',       # cce1e9 in iso-8859-7
-   u'\u0399\u03bf\u03cd\u03bd': u'Jun', # c9effded in iso-8859-7
-   u'\u0399\u03bf\u03bd': u'Jun',       # c9efed in iso-8859-7
-   u'\u0399\u03bf\u03cd\u03bb': u'Jul', # c9effdeb in iso-8859-7
-   u'\u0399\u03bf\u03bb': u'Jul',       # c9f9eb in iso-8859-7
-   u'\u0391\u03cd\u03b3': u'Aug',       # c1fde3 in iso-8859-7
-   u'\u0391\u03c5\u03b3': u'Aug',       # c1f5e3 in iso-8859-7
-   u'\u03a3\u03b5\u03c0': u'Sep',       # d3e5f0 in iso-8859-7
-   u'\u039f\u03ba\u03c4': u'Oct',       # cfeaf4 in iso-8859-7
-   u'\u039d\u03bf\u03ad': u'Nov',       # cdefdd in iso-8859-7
-   u'\u039d\u03bf\u03b5': u'Nov',       # cdefe5 in iso-8859-7
-   u'\u0394\u03b5\u03ba': u'Dec',       # c4e5ea in iso-8859-7
-  }
-
-_greek_wdays = \
-  { \
-   u'\u039a\u03c5\u03c1': u'Sun', # caf5f1 in iso-8859-7
-   u'\u0394\u03b5\u03c5': u'Mon', # c4e5f5 in iso-8859-7
-   u'\u03a4\u03c1\u03b9': u'Tue', # d4f1e9 in iso-8859-7
-   u'\u03a4\u03b5\u03c4': u'Wed', # d4e5f4 in iso-8859-7
-   u'\u03a0\u03b5\u03bc': u'Thu', # d0e5ec in iso-8859-7
-   u'\u03a0\u03b1\u03c1': u'Fri', # d0e1f1 in iso-8859-7
-   u'\u03a3\u03b1\u03b2': u'Sat', # d3e1e2 in iso-8859-7   
-  }
-
-_greek_date_format_re = \
-    re.compile(u'([^,]+),\s+(\d{2})\s+([^\s]+)\s+(\d{4})\s+(\d{2}):(\d{2}):(\d{2})\s+([^\s]+)')
-
-def _parse_date_greek(dateString):
-    '''Parse a string according to a Greek 8-bit date format.'''
-    m = _greek_date_format_re.match(dateString)
-    if not m: return
-    try:
-        wday = _greek_wdays[m.group(1)]
-        month = _greek_months[m.group(3)]
-    except:
-        return
-    rfc822date = '%(wday)s, %(day)s %(month)s %(year)s %(hour)s:%(minute)s:%(second)s %(zonediff)s' % \
-                 {'wday': wday, 'day': m.group(2), 'month': month, 'year': m.group(4),\
-                  'hour': m.group(5), 'minute': m.group(6), 'second': m.group(7),\
-                  'zonediff': m.group(8)}
-    if _debug: sys.stderr.write('Greek date parsed as: %s\n' % rfc822date)
-    return _parse_date_rfc822(rfc822date)
-registerDateHandler(_parse_date_greek)
-
-# Unicode strings for Hungarian date strings
-_hungarian_months = \
-  { \
-    u'janu\u00e1r':   u'01',  # e1 in iso-8859-2
-    u'febru\u00e1ri': u'02',  # e1 in iso-8859-2
-    u'm\u00e1rcius':  u'03',  # e1 in iso-8859-2
-    u'\u00e1prilis':  u'04',  # e1 in iso-8859-2
-    u'm\u00e1ujus':   u'05',  # e1 in iso-8859-2
-    u'j\u00fanius':   u'06',  # fa in iso-8859-2
-    u'j\u00falius':   u'07',  # fa in iso-8859-2
-    u'augusztus':     u'08',
-    u'szeptember':    u'09',
-    u'okt\u00f3ber':  u'10',  # f3 in iso-8859-2
-    u'november':      u'11',
-    u'december':      u'12',
-  }
-
-_hungarian_date_format_re = \
-  re.compile(u'(\d{4})-([^-]+)-(\d{,2})T(\d{,2}):(\d{2})((\+|-)(\d{,2}:\d{2}))')
-
-def _parse_date_hungarian(dateString):
-    '''Parse a string according to a Hungarian 8-bit date format.'''
-    m = _hungarian_date_format_re.match(dateString)
-    if not m: return
-    try:
-        month = _hungarian_months[m.group(2)]
-        day = m.group(3)
-        if len(day) == 1:
-            day = '0' + day
-        hour = m.group(4)
-        if len(hour) == 1:
-            hour = '0' + hour
-    except:
-        return
-    w3dtfdate = '%(year)s-%(month)s-%(day)sT%(hour)s:%(minute)s%(zonediff)s' % \
-                {'year': m.group(1), 'month': month, 'day': day,\
-                 'hour': hour, 'minute': m.group(5),\
-                 'zonediff': m.group(6)}
-    if _debug: sys.stderr.write('Hungarian date parsed as: %s\n' % w3dtfdate)
-    return _parse_date_w3dtf(w3dtfdate)
-registerDateHandler(_parse_date_hungarian)
-
-# W3DTF-style date parsing adapted from PyXML xml.utils.iso8601, written by
-# Drake and licensed under the Python license.  Removed all range checking
-# for month, day, hour, minute, and second, since mktime will normalize
-# these later
-def _parse_date_w3dtf(dateString):
-    def __extract_date(m):
-        year = int(m.group('year'))
-        if year < 100:
-            year = 100 * int(time.gmtime()[0] / 100) + int(year)
-        if year < 1000:
-            return 0, 0, 0
-        julian = m.group('julian')
-        if julian:
-            julian = int(julian)
-            month = julian / 30 + 1
-            day = julian % 30 + 1
-            jday = None
-            while jday != julian:
-                t = time.mktime((year, month, day, 0, 0, 0, 0, 0, 0))
-                jday = time.gmtime(t)[-2]
-                diff = abs(jday - julian)
-                if jday > julian:
-                    if diff < day:
-                        day = day - diff
-                    else:
-                        month = month - 1
-                        day = 31
-                elif jday < julian:
-                    if day + diff < 28:
-                       day = day + diff
-                    else:
-                        month = month + 1
-            return year, month, day
-        month = m.group('month')
-        day = 1
-        if month is None:
-            month = 1
-        else:
-            month = int(month)
-            day = m.group('day')
-            if day:
-                day = int(day)
-            else:
-                day = 1
-        return year, month, day
-
-    def __extract_time(m):
-        if not m:
-            return 0, 0, 0
-        hours = m.group('hours')
-        if not hours:
-            return 0, 0, 0
-        hours = int(hours)
-        minutes = int(m.group('minutes'))
-        seconds = m.group('seconds')
-        if seconds:
-            seconds = int(seconds)
-        else:
-            seconds = 0
-        return hours, minutes, seconds
-
-    def __extract_tzd(m):
-        '''Return the Time Zone Designator as an offset in seconds from UTC.'''
-        if not m:
-            return 0
-        tzd = m.group('tzd')
-        if not tzd:
-            return 0
-        if tzd == 'Z':
-            return 0
-        hours = int(m.group('tzdhours'))
-        minutes = m.group('tzdminutes')
-        if minutes:
-            minutes = int(minutes)
-        else:
-            minutes = 0
-        offset = (hours*60 + minutes) * 60
-        if tzd[0] == '+':
-            return -offset
-        return offset
-
-    __date_re = ('(?P<year>\d\d\d\d)'
-                 '(?:(?P<dsep>-|)'
-                 '(?:(?P<month>\d\d)(?:(?P=dsep)(?P<day>\d\d))?'
-                 '|(?P<julian>\d\d\d)))?')
-    __tzd_re = '(?P<tzd>[-+](?P<tzdhours>\d\d)(?::?(?P<tzdminutes>\d\d))|Z)'
-    __tzd_rx = re.compile(__tzd_re)
-    __time_re = ('(?P<hours>\d\d)(?P<tsep>:|)(?P<minutes>\d\d)'
-                 '(?:(?P=tsep)(?P<seconds>\d\d)(?:[.,]\d+)?)?'
-                 + __tzd_re)
-    __datetime_re = '%s(?:T%s)?' % (__date_re, __time_re)
-    __datetime_rx = re.compile(__datetime_re)
-    m = __datetime_rx.match(dateString)
-    if (m is None) or (m.group() != dateString): return
-    gmt = __extract_date(m) + __extract_time(m) + (0, 0, 0)
-    if gmt[0] == 0: return
-    return time.gmtime(time.mktime(gmt) + __extract_tzd(m) - time.timezone)
-registerDateHandler(_parse_date_w3dtf)
-
-def _parse_date_rfc822(dateString):
-    '''Parse an RFC822, RFC1123, RFC2822, or asctime-style date'''
-    data = dateString.split()
-    if data[0][-1] in (',', '.') or data[0].lower() in rfc822._daynames:
-        del data[0]
-    if len(data) == 4:
-        s = data[3]
-        i = s.find('+')
-        if i > 0:
-            data[3:] = [s[:i], s[i+1:]]
-        else:
-            data.append('')
-        dateString = " ".join(data)
-    # Account for the Etc/GMT timezone by stripping 'Etc/'
-    elif len(data) == 5 and data[4].lower().startswith('etc/'):
-        data[4] = data[4][4:]
-        dateString = " ".join(data)
-    if len(data) < 5:
-        dateString += ' 00:00:00 GMT'
-    tm = rfc822.parsedate_tz(dateString)
-    if tm:
-        return time.gmtime(rfc822.mktime_tz(tm))
-# rfc822.py defines several time zones, but we define some extra ones.
-# 'ET' is equivalent to 'EST', etc.
-_additional_timezones = {'AT': -400, 'ET': -500, 'CT': -600, 'MT': -700, 'PT': -800}
-rfc822._timezones.update(_additional_timezones)
-registerDateHandler(_parse_date_rfc822)    
-
-def _parse_date_perforce(aDateString):
-	"""parse a date in yyyy/mm/dd hh:mm:ss TTT format"""
-	# Fri, 2006/09/15 08:19:53 EDT
-	_my_date_pattern = re.compile( \
-		r'(\w{,3}), (\d{,4})/(\d{,2})/(\d{2}) (\d{,2}):(\d{2}):(\d{2}) (\w{,3})')
-
-	dow, year, month, day, hour, minute, second, tz = \
-		_my_date_pattern.search(aDateString).groups()
-	months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
-	dateString = "%s, %s %s %s %s:%s:%s %s" % (dow, day, months[int(month) - 1], year, hour, minute, second, tz)
-	tm = rfc822.parsedate_tz(dateString)
-	if tm:
-		return time.gmtime(rfc822.mktime_tz(tm))
-registerDateHandler(_parse_date_perforce)
-
-def _parse_date(dateString):
-    '''Parses a variety of date formats into a 9-tuple in GMT'''
-    for handler in _date_handlers:
-        try:
-            date9tuple = handler(dateString)
-            if not date9tuple: continue
-            if len(date9tuple) != 9:
-                if _debug: sys.stderr.write('date handler function must return 9-tuple\n')
-                raise ValueError
-            map(int, date9tuple)
-            return date9tuple
-        except Exception, e:
-            if _debug: sys.stderr.write('%s raised %s\n' % (handler.__name__, repr(e)))
-            pass
-    return None
-
-def _getCharacterEncoding(http_headers, xml_data):
-    '''Get the character encoding of the XML document
-
-    http_headers is a dictionary
-    xml_data is a raw string (not Unicode)
-    
-    This is so much trickier than it sounds, it's not even funny.
-    According to RFC 3023 ('XML Media Types'), if the HTTP Content-Type
-    is application/xml, application/*+xml,
-    application/xml-external-parsed-entity, or application/xml-dtd,
-    the encoding given in the charset parameter of the HTTP Content-Type
-    takes precedence over the encoding given in the XML prefix within the
-    document, and defaults to 'utf-8' if neither are specified.  But, if
-    the HTTP Content-Type is text/xml, text/*+xml, or
-    text/xml-external-parsed-entity, the encoding given in the XML prefix
-    within the document is ALWAYS IGNORED and only the encoding given in
-    the charset parameter of the HTTP Content-Type header should be
-    respected, and it defaults to 'us-ascii' if not specified.
-
-    Furthermore, discussion on the atom-syntax mailing list with the
-    author of RFC 3023 leads me to the conclusion that any document
-    served with a Content-Type of text/* and no charset parameter
-    must be treated as us-ascii.  (We now do this.)  And also that it
-    must always be flagged as non-well-formed.  (We now do this too.)
-    
-    If Content-Type is unspecified (input was local file or non-HTTP source)
-    or unrecognized (server just got it totally wrong), then go by the
-    encoding given in the XML prefix of the document and default to
-    'iso-8859-1' as per the HTTP specification (RFC 2616).
-    
-    Then, assuming we didn't find a character encoding in the HTTP headers
-    (and the HTTP Content-type allowed us to look in the body), we need
-    to sniff the first few bytes of the XML data and try to determine
-    whether the encoding is ASCII-compatible.  Section F of the XML
-    specification shows the way here:
-    http://www.w3.org/TR/REC-xml/#sec-guessing-no-ext-info
-
-    If the sniffed encoding is not ASCII-compatible, we need to make it
-    ASCII compatible so that we can sniff further into the XML declaration
-    to find the encoding attribute, which will tell us the true encoding.
-
-    Of course, none of this guarantees that we will be able to parse the
-    feed in the declared character encoding (assuming it was declared
-    correctly, which many are not).  CJKCodecs and iconv_codec help a lot;
-    you should definitely install them if you can.
-    http://cjkpython.i18n.org/
-    '''
-
-    def _parseHTTPContentType(content_type):
-        '''takes HTTP Content-Type header and returns (content type, charset)
-
-        If no charset is specified, returns (content type, '')
-        If no content type is specified, returns ('', '')
-        Both return parameters are guaranteed to be lowercase strings
-        '''
-        content_type = content_type or ''
-        content_type, params = cgi.parse_header(content_type)
-        return content_type, params.get('charset', '').replace("'", '')
-
-    sniffed_xml_encoding = ''
-    xml_encoding = ''
-    true_encoding = ''
-    http_content_type, http_encoding = _parseHTTPContentType(http_headers.get('content-type', http_headers.get('Content-type')))
-    # Must sniff for non-ASCII-compatible character encodings before
-    # searching for XML declaration.  This heuristic is defined in
-    # section F of the XML specification:
-    # http://www.w3.org/TR/REC-xml/#sec-guessing-no-ext-info
-    try:
-        if xml_data[:4] == _l2bytes([0x4c, 0x6f, 0xa7, 0x94]):
-            # EBCDIC
-            xml_data = _ebcdic_to_ascii(xml_data)
-        elif xml_data[:4] == _l2bytes([0x00, 0x3c, 0x00, 0x3f]):
-            # UTF-16BE
-            sniffed_xml_encoding = 'utf-16be'
-            xml_data = unicode(xml_data, 'utf-16be').encode('utf-8')
-        elif (len(xml_data) >= 4) and (xml_data[:2] == _l2bytes([0xfe, 0xff])) and (xml_data[2:4] != _l2bytes([0x00, 0x00])):
-            # UTF-16BE with BOM
-            sniffed_xml_encoding = 'utf-16be'
-            xml_data = unicode(xml_data[2:], 'utf-16be').encode('utf-8')
-        elif xml_data[:4] == _l2bytes([0x3c, 0x00, 0x3f, 0x00]):
-            # UTF-16LE
-            sniffed_xml_encoding = 'utf-16le'
-            xml_data = unicode(xml_data, 'utf-16le').encode('utf-8')
-        elif (len(xml_data) >= 4) and (xml_data[:2] == _l2bytes([0xff, 0xfe])) and (xml_data[2:4] != _l2bytes([0x00, 0x00])):
-            # UTF-16LE with BOM
-            sniffed_xml_encoding = 'utf-16le'
-            xml_data = unicode(xml_data[2:], 'utf-16le').encode('utf-8')
-        elif xml_data[:4] == _l2bytes([0x00, 0x00, 0x00, 0x3c]):
-            # UTF-32BE
-            sniffed_xml_encoding = 'utf-32be'
-            xml_data = unicode(xml_data, 'utf-32be').encode('utf-8')
-        elif xml_data[:4] == _l2bytes([0x3c, 0x00, 0x00, 0x00]):
-            # UTF-32LE
-            sniffed_xml_encoding = 'utf-32le'
-            xml_data = unicode(xml_data, 'utf-32le').encode('utf-8')
-        elif xml_data[:4] == _l2bytes([0x00, 0x00, 0xfe, 0xff]):
-            # UTF-32BE with BOM
-            sniffed_xml_encoding = 'utf-32be'
-            xml_data = unicode(xml_data[4:], 'utf-32be').encode('utf-8')
-        elif xml_data[:4] == _l2bytes([0xff, 0xfe, 0x00, 0x00]):
-            # UTF-32LE with BOM
-            sniffed_xml_encoding = 'utf-32le'
-            xml_data = unicode(xml_data[4:], 'utf-32le').encode('utf-8')
-        elif xml_data[:3] == _l2bytes([0xef, 0xbb, 0xbf]):
-            # UTF-8 with BOM
-            sniffed_xml_encoding = 'utf-8'
-            xml_data = unicode(xml_data[3:], 'utf-8').encode('utf-8')
-        else:
-            # ASCII-compatible
-            pass
-        xml_encoding_match = re.compile(_s2bytes('^<\?.*encoding=[\'"](.*?)[\'"].*\?>')).match(xml_data)
-    except:
-        xml_encoding_match = None
-    if xml_encoding_match:
-        xml_encoding = xml_encoding_match.groups()[0].decode('utf-8').lower()
-        if sniffed_xml_encoding and (xml_encoding in ('iso-10646-ucs-2', 'ucs-2', 'csunicode', 'iso-10646-ucs-4', 'ucs-4', 'csucs4', 'utf-16', 'utf-32', 'utf_16', 'utf_32', 'utf16', 'u16')):
-            xml_encoding = sniffed_xml_encoding
-    acceptable_content_type = 0
-    application_content_types = ('application/xml', 'application/xml-dtd', 'application/xml-external-parsed-entity')
-    text_content_types = ('text/xml', 'text/xml-external-parsed-entity')
-    if (http_content_type in application_content_types) or \
-       (http_content_type.startswith('application/') and http_content_type.endswith('+xml')):
-        acceptable_content_type = 1
-        true_encoding = http_encoding or xml_encoding or 'utf-8'
-    elif (http_content_type in text_content_types) or \
-         (http_content_type.startswith('text/')) and http_content_type.endswith('+xml'):
-        acceptable_content_type = 1
-        true_encoding = http_encoding or 'us-ascii'
-    elif http_content_type.startswith('text/'):
-        true_encoding = http_encoding or 'us-ascii'
-    elif http_headers and (not (http_headers.has_key('content-type') or http_headers.has_key('Content-type'))):
-        true_encoding = xml_encoding or 'iso-8859-1'
-    else:
-        true_encoding = xml_encoding or 'utf-8'
-    # some feeds claim to be gb2312 but are actually gb18030.
-    # apparently MSIE and Firefox both do the following switch:
-    if true_encoding.lower() == 'gb2312':
-        true_encoding = 'gb18030'
-    return true_encoding, http_encoding, xml_encoding, sniffed_xml_encoding, acceptable_content_type
-    
-def _toUTF8(data, encoding):
-    '''Changes an XML data stream on the fly to specify a new encoding
-
-    data is a raw sequence of bytes (not Unicode) that is presumed to be in %encoding already
-    encoding is a string recognized by encodings.aliases
-    '''
-    if _debug: sys.stderr.write('entering _toUTF8, trying encoding %s\n' % encoding)
-    # strip Byte Order Mark (if present)
-    if (len(data) >= 4) and (data[:2] == _l2bytes([0xfe, 0xff])) and (data[2:4] != _l2bytes([0x00, 0x00])):
-        if _debug:
-            sys.stderr.write('stripping BOM\n')
-            if encoding != 'utf-16be':
-                sys.stderr.write('trying utf-16be instead\n')
-        encoding = 'utf-16be'
-        data = data[2:]
-    elif (len(data) >= 4) and (data[:2] == _l2bytes([0xff, 0xfe])) and (data[2:4] != _l2bytes([0x00, 0x00])):
-        if _debug:
-            sys.stderr.write('stripping BOM\n')
-            if encoding != 'utf-16le':
-                sys.stderr.write('trying utf-16le instead\n')
-        encoding = 'utf-16le'
-        data = data[2:]
-    elif data[:3] == _l2bytes([0xef, 0xbb, 0xbf]):
-        if _debug:
-            sys.stderr.write('stripping BOM\n')
-            if encoding != 'utf-8':
-                sys.stderr.write('trying utf-8 instead\n')
-        encoding = 'utf-8'
-        data = data[3:]
-    elif data[:4] == _l2bytes([0x00, 0x00, 0xfe, 0xff]):
-        if _debug:
-            sys.stderr.write('stripping BOM\n')
-            if encoding != 'utf-32be':
-                sys.stderr.write('trying utf-32be instead\n')
-        encoding = 'utf-32be'
-        data = data[4:]
-    elif data[:4] == _l2bytes([0xff, 0xfe, 0x00, 0x00]):
-        if _debug:
-            sys.stderr.write('stripping BOM\n')
-            if encoding != 'utf-32le':
-                sys.stderr.write('trying utf-32le instead\n')
-        encoding = 'utf-32le'
-        data = data[4:]
-    newdata = unicode(data, encoding)
-    if _debug: sys.stderr.write('successfully converted %s data to unicode\n' % encoding)
-    declmatch = re.compile('^<\?xml[^>]*?>')
-    newdecl = '''<?xml version='1.0' encoding='utf-8'?>'''
-    if declmatch.search(newdata):
-        newdata = declmatch.sub(newdecl, newdata)
-    else:
-        newdata = newdecl + u'\n' + newdata
-    return newdata.encode('utf-8')
-
-def _stripDoctype(data):
-    '''Strips DOCTYPE from XML document, returns (rss_version, stripped_data)
-
-    rss_version may be 'rss091n' or None
-    stripped_data is the same XML document, minus the DOCTYPE
-    '''
-    start = re.search(_s2bytes('<\w'), data)
-    start = start and start.start() or -1
-    head,data = data[:start+1], data[start+1:]
-    
-    entity_pattern = re.compile(_s2bytes(r'^\s*<!ENTITY([^>]*?)>'), re.MULTILINE)
-    entity_results=entity_pattern.findall(head)
-    head = entity_pattern.sub(_s2bytes(''), head)
-    doctype_pattern = re.compile(_s2bytes(r'^\s*<!DOCTYPE([^>]*?)>'), re.MULTILINE)
-    doctype_results = doctype_pattern.findall(head)
-    doctype = doctype_results and doctype_results[0] or _s2bytes('')
-    if doctype.lower().count(_s2bytes('netscape')):
-        version = 'rss091n'
-    else:
-        version = None
-
-    # only allow in 'safe' inline entity definitions
-    replacement=_s2bytes('')
-    if len(doctype_results)==1 and entity_results:
-       safe_pattern=re.compile(_s2bytes('\s+(\w+)\s+"(&#\w+;|[^&"]*)"'))
-       safe_entities=filter(lambda e: safe_pattern.match(e),entity_results)
-       if safe_entities:
-           replacement=_s2bytes('<!DOCTYPE feed [\n  <!ENTITY') + _s2bytes('>\n  <!ENTITY ').join(safe_entities) + _s2bytes('>\n]>')
-    data = doctype_pattern.sub(replacement, head) + data
-
-    return version, data, dict(replacement and [(k.decode('utf-8'), v.decode('utf-8')) for k, v in safe_pattern.findall(replacement)])
-    
-def parse(url_file_stream_or_string, etag=None, modified=None, agent=None, referrer=None, handlers=[], request_headers={}, response_headers={}):
-    '''Parse a feed from a URL, file, stream, or string.
-    
-    request_headers, if given, is a dict from http header name to value to add
-    to the request; this overrides internally generated values.
-    '''
-    result = FeedParserDict()
-    result['feed'] = FeedParserDict()
-    result['entries'] = []
-    if _XML_AVAILABLE:
-        result['bozo'] = 0
-    if not isinstance(handlers, list):
-        handlers = [handlers]
-    try:
-        f = _open_resource(url_file_stream_or_string, etag, modified, agent, referrer, handlers, request_headers)
-        data = f.read()
-    except Exception, e:
-        result['bozo'] = 1
-        result['bozo_exception'] = e
-        data = None
-        f = None
-
-    if hasattr(f, 'headers'):
-        result['headers'] = dict(f.headers)
-    # overwrite existing headers using response_headers
-    if 'headers' in result:
-        result['headers'].update(response_headers)
-    elif response_headers:
-        result['headers'] = copy.deepcopy(response_headers)
-
-    # if feed is gzip-compressed, decompress it
-    if f and data and 'headers' in result:
-        if gzip and result['headers'].get('content-encoding') == 'gzip':
-            try:
-                data = gzip.GzipFile(fileobj=_StringIO(data)).read()
-            except Exception, e:
-                # Some feeds claim to be gzipped but they're not, so
-                # we get garbage.  Ideally, we should re-request the
-                # feed without the 'Accept-encoding: gzip' header,
-                # but we don't.
-                result['bozo'] = 1
-                result['bozo_exception'] = e
-                data = ''
-        elif zlib and result['headers'].get('content-encoding') == 'deflate':
-            try:
-                data = zlib.decompress(data, -zlib.MAX_WBITS)
-            except Exception, e:
-                result['bozo'] = 1
-                result['bozo_exception'] = e
-                data = ''
-
-    # save HTTP headers
-    if 'headers' in result:
-        if 'etag' in result['headers'] or 'ETag' in result['headers']:
-            etag = result['headers'].get('etag', result['headers'].get('ETag'))
-            if etag:
-                result['etag'] = etag
-        if 'last-modified' in result['headers'] or 'Last-Modified' in result['headers']:
-            modified = result['headers'].get('last-modified', result['headers'].get('Last-Modified'))
-            if modified:
-                result['modified'] = _parse_date(modified)
-    if hasattr(f, 'url'):
-        result['href'] = f.url
-        result['status'] = 200
-    if hasattr(f, 'status'):
-        result['status'] = f.status
-    if hasattr(f, 'close'):
-        f.close()
-
-    # there are four encodings to keep track of:
-    # - http_encoding is the encoding declared in the Content-Type HTTP header
-    # - xml_encoding is the encoding declared in the <?xml declaration
-    # - sniffed_encoding is the encoding sniffed from the first 4 bytes of the XML data
-    # - result['encoding'] is the actual encoding, as per RFC 3023 and a variety of other conflicting specifications
-    http_headers = result.get('headers', {})
-    result['encoding'], http_encoding, xml_encoding, sniffed_xml_encoding, acceptable_content_type = \
-        _getCharacterEncoding(http_headers, data)
-    if http_headers and (not acceptable_content_type):
-        if http_headers.has_key('content-type') or http_headers.has_key('Content-type'):
-            bozo_message = '%s is not an XML media type' % http_headers.get('content-type', http_headers.get('Content-type'))
-        else:
-            bozo_message = 'no Content-type specified'
-        result['bozo'] = 1
-        result['bozo_exception'] = NonXMLContentType(bozo_message)
-
-    if data is not None:
-        result['version'], data, entities = _stripDoctype(data)
-
-    # ensure that baseuri is an absolute uri using an acceptable URI scheme
-    contentloc = http_headers.get('content-location', http_headers.get('Content-Location', ''))
-    href = result.get('href', '')
-    baseuri = _makeSafeAbsoluteURI(href, contentloc) or _makeSafeAbsoluteURI(contentloc) or href
-
-    baselang = http_headers.get('content-language', http_headers.get('Content-Language', None))
-
-    # if server sent 304, we're done
-    if result.get('status', 0) == 304:
-        result['version'] = ''
-        result['debug_message'] = 'The feed has not changed since you last checked, ' + \
-            'so the server sent no data.  This is a feature, not a bug!'
-        return result
-
-    # if there was a problem downloading, we're done
-    if data is None:
-        return result
-
-    # determine character encoding
-    use_strict_parser = 0
-    known_encoding = 0
-    tried_encodings = []
-    # try: HTTP encoding, declared XML encoding, encoding sniffed from BOM
-    for proposed_encoding in (result['encoding'], xml_encoding, sniffed_xml_encoding):
-        if not proposed_encoding: continue
-        if proposed_encoding in tried_encodings: continue
-        tried_encodings.append(proposed_encoding)
-        try:
-            data = _toUTF8(data, proposed_encoding)
-            known_encoding = use_strict_parser = 1
-            break
-        except:
-            pass
-    # if no luck and we have auto-detection library, try that
-    if (not known_encoding) and chardet:
-        try:
-            proposed_encoding = chardet.detect(data)['encoding']
-            if proposed_encoding and (proposed_encoding not in tried_encodings):
-                tried_encodings.append(proposed_encoding)
-                data = _toUTF8(data, proposed_encoding)
-                known_encoding = use_strict_parser = 1
-        except:
-            pass
-    # if still no luck and we haven't tried utf-8 yet, try that
-    if (not known_encoding) and ('utf-8' not in tried_encodings):
-        try:
-            proposed_encoding = 'utf-8'
-            tried_encodings.append(proposed_encoding)
-            data = _toUTF8(data, proposed_encoding)
-            known_encoding = use_strict_parser = 1
-        except:
-            pass
-    # if still no luck and we haven't tried windows-1252 yet, try that
-    if (not known_encoding) and ('windows-1252' not in tried_encodings):
-        try:
-            proposed_encoding = 'windows-1252'
-            tried_encodings.append(proposed_encoding)
-            data = _toUTF8(data, proposed_encoding)
-            known_encoding = use_strict_parser = 1
-        except:
-            pass
-    # if still no luck and we haven't tried iso-8859-2 yet, try that.
-    if (not known_encoding) and ('iso-8859-2' not in tried_encodings):
-        try:
-            proposed_encoding = 'iso-8859-2'
-            tried_encodings.append(proposed_encoding)
-            data = _toUTF8(data, proposed_encoding)
-            known_encoding = use_strict_parser = 1
-        except:
-            pass
-    # if still no luck, give up
-    if not known_encoding:
-        result['bozo'] = 1
-        result['bozo_exception'] = CharacterEncodingUnknown( \
-            'document encoding unknown, I tried ' + \
-            '%s, %s, utf-8, windows-1252, and iso-8859-2 but nothing worked' % \
-            (result['encoding'], xml_encoding))
-        result['encoding'] = ''
-    elif proposed_encoding != result['encoding']:
-        result['bozo'] = 1
-        result['bozo_exception'] = CharacterEncodingOverride( \
-            'document declared as %s, but parsed as %s' % \
-            (result['encoding'], proposed_encoding))
-        result['encoding'] = proposed_encoding
-
-    if not _XML_AVAILABLE:
-        use_strict_parser = 0
-    if use_strict_parser:
-        # initialize the SAX parser
-        feedparser = _StrictFeedParser(baseuri, baselang, 'utf-8')
-        saxparser = xml.sax.make_parser(PREFERRED_XML_PARSERS)
-        saxparser.setFeature(xml.sax.handler.feature_namespaces, 1)
-        saxparser.setContentHandler(feedparser)
-        saxparser.setErrorHandler(feedparser)
-        source = xml.sax.xmlreader.InputSource()
-        source.setByteStream(_StringIO(data))
-        if hasattr(saxparser, '_ns_stack'):
-            # work around bug in built-in SAX parser (doesn't recognize xml: namespace)
-            # PyXML doesn't have this problem, and it doesn't have _ns_stack either
-            saxparser._ns_stack.append({'http://www.w3.org/XML/1998/namespace':'xml'})
-        try:
-            saxparser.parse(source)
-        except Exception, e:
-            if _debug:
-                import traceback
-                traceback.print_stack()
-                traceback.print_exc()
-                sys.stderr.write('xml parsing failed\n')
-            result['bozo'] = 1
-            result['bozo_exception'] = feedparser.exc or e
-            use_strict_parser = 0
-    if not use_strict_parser:
-        feedparser = _LooseFeedParser(baseuri, baselang, 'utf-8', entities)
-        feedparser.feed(data.decode('utf-8', 'replace'))
-    result['feed'] = feedparser.feeddata
-    result['entries'] = feedparser.entries
-    result['version'] = result['version'] or feedparser.version
-    result['namespaces'] = feedparser.namespacesInUse
-    return result
-
-class Serializer:
-    def __init__(self, results):
-        self.results = results
-
-class TextSerializer(Serializer):
-    def write(self, stream=sys.stdout):
-        self._writer(stream, self.results, '')
-
-    def _writer(self, stream, node, prefix):
-        if not node: return
-        if hasattr(node, 'keys'):
-            keys = node.keys()
-            keys.sort()
-            for k in keys:
-                if k in ('description', 'link'): continue
-                if node.has_key(k + '_detail'): continue
-                if node.has_key(k + '_parsed'): continue
-                self._writer(stream, node[k], prefix + k + '.')
-        elif type(node) == types.ListType:
-            index = 0
-            for n in node:
-                self._writer(stream, n, prefix[:-1] + '[' + str(index) + '].')
-                index += 1
-        else:
-            try:
-                s = str(node).encode('utf-8')
-                s = s.replace('\\', '\\\\')
-                s = s.replace('\r', '')
-                s = s.replace('\n', r'\n')
-                stream.write(prefix[:-1])
-                stream.write('=')
-                stream.write(s)
-                stream.write('\n')
-            except:
-                pass
-        
-class PprintSerializer(Serializer):
-    def write(self, stream=sys.stdout):
-        if self.results.has_key('href'):
-            stream.write(self.results['href'] + '\n\n')
-        from pprint import pprint
-        pprint(self.results, stream)
-        stream.write('\n')
-        
-if __name__ == '__main__':
-    try:
-        from optparse import OptionParser
-    except:
-        OptionParser = None
-
-    if OptionParser:
-        optionParser = OptionParser(version=__version__, usage="%prog [options] url_or_filename_or_-")
-        optionParser.set_defaults(format="pprint")
-        optionParser.add_option("-A", "--user-agent", dest="agent", metavar="AGENT", help="User-Agent for HTTP URLs")
-        optionParser.add_option("-e", "--referer", "--referrer", dest="referrer", metavar="URL", help="Referrer for HTTP URLs")
-        optionParser.add_option("-t", "--etag", dest="etag", metavar="TAG", help="ETag/If-None-Match for HTTP URLs")
-        optionParser.add_option("-m", "--last-modified", dest="modified", metavar="DATE", help="Last-modified/If-Modified-Since for HTTP URLs (any supported date format)")
-        optionParser.add_option("-f", "--format", dest="format", metavar="FORMAT", help="output results in FORMAT (text, pprint)")
-        optionParser.add_option("-v", "--verbose", action="store_true", dest="verbose", default=False, help="write debugging information to stderr")
-        (options, urls) = optionParser.parse_args()
-        if options.verbose:
-            _debug = 1
-        if not urls:
-            optionParser.print_help()
-            sys.exit(0)
-    else:
-        if not sys.argv[1:]:
-            print __doc__
-            sys.exit(0)
-        class _Options:
-            etag = modified = agent = referrer = None
-            format = 'pprint'
-        options = _Options()
-        urls = sys.argv[1:]
-
-    zopeCompatibilityHack()
-
-    serializer = globals().get(options.format.capitalize() + 'Serializer', Serializer)
-    for url in urls:
-        results = parse(url, etag=options.etag, modified=options.modified, agent=options.agent, referrer=options.referrer)
-        serializer(results).write(sys.stdout)
diff --git a/module/forwarder.py b/module/lib/forwarder.py
index eacb33c2b..eacb33c2b 100644
--- a/module/forwarder.py
+++ b/module/lib/forwarder.py
diff --git a/module/lib/hg_tool.py b/module/lib/hg_tool.py
new file mode 100644
index 000000000..cd97833df
--- /dev/null
+++ b/module/lib/hg_tool.py
@@ -0,0 +1,133 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import re
+from subprocess import Popen, PIPE
+from time import time, gmtime, strftime
+
+aliases = {"zoidber": "zoidberg", "zoidberg10": "zoidberg", "webmaster": "dhmh", "mast3rranan": "ranan",
+           "ranan2": "ranan"}
+exclude = ["locale/*", "module/lib/*"]
+date_format = "%Y-%m-%d"
+line_re = re.compile(r" (\d+) \**", re.I)
+
+def add_exclude_flags(args):
+    for dir in exclude:
+        args.extend(["-X", dir])
+
+# remove small percentages
+def wipe(data, perc=1):
+    s = (sum(data.values()) * perc) / 100
+    for k, v in data.items():
+        if v < s: del data[k]
+
+    return data
+
+# remove aliases
+def de_alias(data):
+    for k, v in aliases.iteritems():
+        if k not in data: continue
+        alias = aliases[k]
+
+        if alias in data: data[alias] += data[k]
+        else: data[alias] = data[k]
+
+        del data[k]
+
+    return data
+
+
+def output(data):
+    s = float(sum(data.values()))
+    print "Total Lines: %d" % s
+    for k, v in data.iteritems():
+        print "%15s: %.1f%% | %d" % (k, (v * 100) / s, v)
+    print
+
+
+def file_list():
+    args = ["hg", "status", "-A"]
+    add_exclude_flags(args)
+    p = Popen(args, stdout=PIPE)
+    out, err = p.communicate()
+    return [x.split()[1] for x in out.splitlines() if x.split()[0] in "CMA"]
+
+
+def hg_annotate(path):
+    args = ["hg", "annotate", "-u", path]
+    p = Popen(args, stdout=PIPE)
+    out, err = p.communicate()
+
+    data = {}
+
+    for line in out.splitlines():
+        author, non, line = line.partition(":")
+
+        # probably binary file
+        if author == path: return {}
+
+        author = author.strip().lower()
+        if not line.strip(): continue # don't count blank lines
+
+        if author in data: data[author] += 1
+        else: data[author] = 1
+
+    return de_alias(data)
+
+
+def hg_churn(days=None):
+    args = ["hg", "churn"]
+    if days:
+        args.append("-d")
+        t = time() - 60 * 60 * 24 * days
+        args.append("%s to %s" % (strftime(date_format, gmtime(t)), strftime(date_format)))
+
+    add_exclude_flags(args)
+    p = Popen(args, stdout=PIPE)
+    out, err = p.communicate()
+
+    data = {}
+
+    for line in out.splitlines():
+        m = line_re.search(line)
+        author = line.split()[0]
+        lines = int(m.group(1))
+
+        if "@" in author:
+            author, n, email = author.partition("@")
+
+        author = author.strip().lower()
+
+        if author in data: data[author] += lines
+        else: data[author] = lines
+
+    return de_alias(data)
+
+
+def complete_annotate():
+    files = file_list()
+    data = {}
+    for f in files:
+        tmp = hg_annotate(f)
+        for k, v in tmp.iteritems():
+            if k in data: data[k] += v
+            else: data[k] = v
+
+    return data
+
+
+if __name__ == "__main__":
+    for d in (30, 90, 180):
+        c = wipe(hg_churn(d))
+        print "Changes in %d days:" % d
+        output(c)
+
+    c = wipe(hg_churn())
+    print "Total changes:"
+    output(c)
+
+    print "Current source code version:"
+    data = wipe(complete_annotate())
+    output(data)
+
+
diff --git a/module/lib/mod_pywebsocket/COPYING b/module/lib/mod_pywebsocket/COPYING
new file mode 100644
index 000000000..989d02e4c
--- /dev/null
+++ b/module/lib/mod_pywebsocket/COPYING
@@ -0,0 +1,28 @@
+Copyright 2012, Google Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+    * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/module/lib/mod_pywebsocket/__init__.py b/module/lib/mod_pywebsocket/__init__.py
new file mode 100644
index 000000000..454ae0c45
--- /dev/null
+++ b/module/lib/mod_pywebsocket/__init__.py
@@ -0,0 +1,197 @@
+# Copyright 2011, Google Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+"""WebSocket extension for Apache HTTP Server.
+
+mod_pywebsocket is a WebSocket extension for Apache HTTP Server
+intended for testing or experimental purposes. mod_python is required.
+
+
+Installation
+============
+
+0. Prepare an Apache HTTP Server for which mod_python is enabled.
+
+1. Specify the following Apache HTTP Server directives to suit your
+   configuration.
+
+   If mod_pywebsocket is not in the Python path, specify the following.
+   <websock_lib> is the directory where mod_pywebsocket is installed.
+
+       PythonPath "sys.path+['<websock_lib>']"
+
+   Always specify the following. <websock_handlers> is the directory where
+   user-written WebSocket handlers are placed.
+
+       PythonOption mod_pywebsocket.handler_root <websock_handlers>
+       PythonHeaderParserHandler mod_pywebsocket.headerparserhandler
+
+   To limit the search for WebSocket handlers to a directory <scan_dir>
+   under <websock_handlers>, configure as follows:
+
+       PythonOption mod_pywebsocket.handler_scan <scan_dir>
+
+   <scan_dir> is useful in saving scan time when <websock_handlers>
+   contains many non-WebSocket handler files.
+
+   If you want to allow handlers whose canonical path is not under the root
+   directory (i.e. symbolic link is in root directory but its target is not),
+   configure as follows:
+
+       PythonOption mod_pywebsocket.allow_handlers_outside_root_dir On
+
+   Example snippet of httpd.conf:
+   (mod_pywebsocket is in /websock_lib, WebSocket handlers are in
+   /websock_handlers, port is 80 for ws, 443 for wss.)
+
+       <IfModule python_module>
+         PythonPath "sys.path+['/websock_lib']"
+         PythonOption mod_pywebsocket.handler_root /websock_handlers
+         PythonHeaderParserHandler mod_pywebsocket.headerparserhandler
+       </IfModule>
+
+2. Tune Apache parameters for serving WebSocket. We'd like to note that at
+   least TimeOut directive from core features and RequestReadTimeout
+   directive from mod_reqtimeout should be modified not to kill connections
+   in only a few seconds of idle time.
+
+3. Verify installation. You can use example/console.html to poke the server.
+
+
+Writing WebSocket handlers
+==========================
+
+When a WebSocket request comes in, the resource name
+specified in the handshake is considered as if it is a file path under
+<websock_handlers> and the handler defined in
+<websock_handlers>/<resource_name>_wsh.py is invoked.
+
+For example, if the resource name is /example/chat, the handler defined in
+<websock_handlers>/example/chat_wsh.py is invoked.
+
+A WebSocket handler is composed of the following three functions:
+
+    web_socket_do_extra_handshake(request)
+    web_socket_transfer_data(request)
+    web_socket_passive_closing_handshake(request)
+
+where:
+    request: mod_python request.
+
+web_socket_do_extra_handshake is called during the handshake after the
+headers are successfully parsed and WebSocket properties (ws_location,
+ws_origin, and ws_resource) are added to request. A handler
+can reject the request by raising an exception.
+
+A request object has the following properties that you can use during the
+extra handshake (web_socket_do_extra_handshake):
+- ws_resource
+- ws_origin
+- ws_version
+- ws_location (HyBi 00 only)
+- ws_extensions (HyBi 06 and later)
+- ws_deflate (HyBi 06 and later)
+- ws_protocol
+- ws_requested_protocols (HyBi 06 and later)
+
+The last two are a bit tricky. See the next subsection.
+
+
+Subprotocol Negotiation
+-----------------------
+
+For HyBi 06 and later, ws_protocol is always set to None when
+web_socket_do_extra_handshake is called. If ws_requested_protocols is not
+None, you must choose one subprotocol from this list and set it to
+ws_protocol.
+
+For HyBi 00, when web_socket_do_extra_handshake is called,
+ws_protocol is set to the value given by the client in
+Sec-WebSocket-Protocol header or None if
+such header was not found in the opening handshake request. Finish extra
+handshake with ws_protocol untouched to accept the request subprotocol.
+Then, Sec-WebSocket-Protocol header will be sent to
+the client in response with the same value as requested. Raise an exception
+in web_socket_do_extra_handshake to reject the requested subprotocol.
+
+
+Data Transfer
+-------------
+
+web_socket_transfer_data is called after the handshake completed
+successfully. A handler can receive/send messages from/to the client
+using request. mod_pywebsocket.msgutil module provides utilities
+for data transfer.
+
+You can receive a message by the following statement.
+
+    message = request.ws_stream.receive_message()
+
+This call blocks until any complete text frame arrives, and the payload data
+of the incoming frame will be stored into message. When you're using IETF
+HyBi 00 or later protocol, receive_message() will return None on receiving
+client-initiated closing handshake. When any error occurs, receive_message()
+will raise some exception.
+
+You can send a message by the following statement.
+
+    request.ws_stream.send_message(message)
+
+
+Closing Connection
+------------------
+
+Executing the following statement or just return-ing from
+web_socket_transfer_data cause connection close.
+
+    request.ws_stream.close_connection()
+
+close_connection will wait
+for closing handshake acknowledgement coming from the client. When it
+couldn't receive a valid acknowledgement, raises an exception.
+
+web_socket_passive_closing_handshake is called after the server receives
+incoming closing frame from the client peer immediately. You can specify
+code and reason by return values. They are sent as a outgoing closing frame
+from the server. A request object has the following properties that you can
+use in web_socket_passive_closing_handshake.
+- ws_close_code
+- ws_close_reason
+
+
+Threading
+---------
+
+A WebSocket handler must be thread-safe if the server (Apache or
+standalone.py) is configured to use threads.
+"""
+
+
+# vi:sts=4 sw=4 et tw=72
diff --git a/module/lib/mod_pywebsocket/_stream_base.py b/module/lib/mod_pywebsocket/_stream_base.py
new file mode 100644
index 000000000..60fb33d2c
--- /dev/null
+++ b/module/lib/mod_pywebsocket/_stream_base.py
@@ -0,0 +1,165 @@
+# Copyright 2011, Google Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+"""Base stream class.
+"""
+
+
+# Note: request.connection.write/read are used in this module, even though
+# mod_python document says that they should be used only in connection
+# handlers. Unfortunately, we have no other options. For example,
+# request.write/read are not suitable because they don't allow direct raw bytes
+# writing/reading.
+
+
+from mod_pywebsocket import util
+
+
+# Exceptions
+
+
+class ConnectionTerminatedException(Exception):
+    """This exception will be raised when a connection is terminated
+    unexpectedly.
+    """
+
+    pass
+
+
+class InvalidFrameException(ConnectionTerminatedException):
+    """This exception will be raised when we received an invalid frame we
+    cannot parse.
+    """
+
+    pass
+
+
+class BadOperationException(Exception):
+    """This exception will be raised when send_message() is called on
+    server-terminated connection or receive_message() is called on
+    client-terminated connection.
+    """
+
+    pass
+
+
+class UnsupportedFrameException(Exception):
+    """This exception will be raised when we receive a frame with flag, opcode
+    we cannot handle. Handlers can just catch and ignore this exception and
+    call receive_message() again to continue processing the next frame.
+    """
+
+    pass
+
+
+class InvalidUTF8Exception(Exception):
+    """This exception will be raised when we receive a text frame which
+    contains invalid UTF-8 strings.
+    """
+
+    pass
+
+
+class StreamBase(object):
+    """Base stream class."""
+
+    def __init__(self, request):
+        """Construct an instance.
+
+        Args:
+            request: mod_python request.
+        """
+
+        self._logger = util.get_class_logger(self)
+
+        self._request = request
+
+    def _read(self, length):
+        """Reads length bytes from connection. In case we catch any exception,
+        prepends remote address to the exception message and raise again.
+
+        Raises:
+            ConnectionTerminatedException: when read returns empty string.
+        """
+
+        bytes = self._request.connection.read(length)
+        if not bytes:
+            raise ConnectionTerminatedException(
+                'Receiving %d byte failed. Peer (%r) closed connection' %
+                (length, (self._request.connection.remote_addr,)))
+        return bytes
+
+    def _write(self, bytes):
+        """Writes given bytes to connection. In case we catch any exception,
+        prepends remote address to the exception message and raise again.
+        """
+
+        try:
+            self._request.connection.write(bytes)
+        except Exception, e:
+            util.prepend_message_to_exception(
+                    'Failed to send message to %r: ' %
+                            (self._request.connection.remote_addr,),
+                    e)
+            raise
+
+    def receive_bytes(self, length):
+        """Receives multiple bytes. Retries read when we couldn't receive the
+        specified amount.
+
+        Raises:
+            ConnectionTerminatedException: when read returns empty string.
+        """
+
+        bytes = []
+        while length > 0:
+            new_bytes = self._read(length)
+            bytes.append(new_bytes)
+            length -= len(new_bytes)
+        return ''.join(bytes)
+
+    def _read_until(self, delim_char):
+        """Reads bytes until we encounter delim_char. The result will not
+        contain delim_char.
+
+        Raises:
+            ConnectionTerminatedException: when read returns empty string.
+        """
+
+        bytes = []
+        while True:
+            ch = self._read(1)
+            if ch == delim_char:
+                break
+            bytes.append(ch)
+        return ''.join(bytes)
+
+
+# vi:sts=4 sw=4 et
diff --git a/module/lib/mod_pywebsocket/_stream_hixie75.py b/module/lib/mod_pywebsocket/_stream_hixie75.py
new file mode 100644
index 000000000..94cf5b31b
--- /dev/null
+++ b/module/lib/mod_pywebsocket/_stream_hixie75.py
@@ -0,0 +1,229 @@
+# Copyright 2011, Google Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+"""This file provides a class for parsing/building frames of the WebSocket
+protocol version HyBi 00 and Hixie 75.
+
+Specification:
+- HyBi 00 http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-00
+- Hixie 75 http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-75
+"""
+
+
+from mod_pywebsocket import common
+from mod_pywebsocket._stream_base import BadOperationException
+from mod_pywebsocket._stream_base import ConnectionTerminatedException
+from mod_pywebsocket._stream_base import InvalidFrameException
+from mod_pywebsocket._stream_base import StreamBase
+from mod_pywebsocket._stream_base import UnsupportedFrameException
+from mod_pywebsocket import util
+
+
+class StreamHixie75(StreamBase):
+    """A class for parsing/building frames of the WebSocket protocol version
+    HyBi 00 and Hixie 75.
+    """
+
+    def __init__(self, request, enable_closing_handshake=False):
+        """Construct an instance.
+
+        Args:
+            request: mod_python request.
+            enable_closing_handshake: to let StreamHixie75 perform closing
+                                      handshake as specified in HyBi 00, set
+                                      this option to True.
+        """
+
+        StreamBase.__init__(self, request)
+
+        self._logger = util.get_class_logger(self)
+
+        self._enable_closing_handshake = enable_closing_handshake
+
+        self._request.client_terminated = False
+        self._request.server_terminated = False
+
+    def send_message(self, message, end=True, binary=False):
+        """Send message.
+
+        Args:
+            message: unicode string to send.
+            binary: not used in hixie75.
+
+        Raises:
+            BadOperationException: when called on a server-terminated
+                connection.
+        """
+
+        if not end:
+            raise BadOperationException(
+                'StreamHixie75 doesn\'t support send_message with end=False')
+
+        if binary:
+            raise BadOperationException(
+                'StreamHixie75 doesn\'t support send_message with binary=True')
+
+        if self._request.server_terminated:
+            raise BadOperationException(
+                'Requested send_message after sending out a closing handshake')
+
+        self._write(''.join(['\x00', message.encode('utf-8'), '\xff']))
+
+    def _read_payload_length_hixie75(self):
+        """Reads a length header in a Hixie75 version frame with length.
+
+        Raises:
+            ConnectionTerminatedException: when read returns empty string.
+        """
+
+        length = 0
+        while True:
+            b_str = self._read(1)
+            b = ord(b_str)
+            length = length * 128 + (b & 0x7f)
+            if (b & 0x80) == 0:
+                break
+        return length
+
+    def receive_message(self):
+        """Receive a WebSocket frame and return its payload an unicode string.
+
+        Returns:
+            payload unicode string in a WebSocket frame.
+
+        Raises:
+            ConnectionTerminatedException: when read returns empty
+                string.
+            BadOperationException: when called on a client-terminated
+                connection.
+        """
+
+        if self._request.client_terminated:
+            raise BadOperationException(
+                'Requested receive_message after receiving a closing '
+                'handshake')
+
+        while True:
+            # Read 1 byte.
+            # mp_conn.read will block if no bytes are available.
+            # Timeout is controlled by TimeOut directive of Apache.
+            frame_type_str = self.receive_bytes(1)
+            frame_type = ord(frame_type_str)
+            if (frame_type & 0x80) == 0x80:
+                # The payload length is specified in the frame.
+                # Read and discard.
+                length = self._read_payload_length_hixie75()
+                if length > 0:
+                    _ = self.receive_bytes(length)
+                # 5.3 3. 12. if /type/ is 0xFF and /length/ is 0, then set the
+                # /client terminated/ flag and abort these steps.
+                if not self._enable_closing_handshake:
+                    continue
+
+                if frame_type == 0xFF and length == 0:
+                    self._request.client_terminated = True
+
+                    if self._request.server_terminated:
+                        self._logger.debug(
+                            'Received ack for server-initiated closing '
+                            'handshake')
+                        return None
+
+                    self._logger.debug(
+                        'Received client-initiated closing handshake')
+
+                    self._send_closing_handshake()
+                    self._logger.debug(
+                        'Sent ack for client-initiated closing handshake')
+                    return None
+            else:
+                # The payload is delimited with \xff.
+                bytes = self._read_until('\xff')
+                # The WebSocket protocol section 4.4 specifies that invalid
+                # characters must be replaced with U+fffd REPLACEMENT
+                # CHARACTER.
+                message = bytes.decode('utf-8', 'replace')
+                if frame_type == 0x00:
+                    return message
+                # Discard data of other types.
+
+    def _send_closing_handshake(self):
+        if not self._enable_closing_handshake:
+            raise BadOperationException(
+                'Closing handshake is not supported in Hixie 75 protocol')
+
+        self._request.server_terminated = True
+
+        # 5.3 the server may decide to terminate the WebSocket connection by
+        # running through the following steps:
+        # 1. send a 0xFF byte and a 0x00 byte to the client to indicate the
+        # start of the closing handshake.
+        self._write('\xff\x00')
+
+    def close_connection(self, unused_code='', unused_reason=''):
+        """Closes a WebSocket connection.
+
+        Raises:
+            ConnectionTerminatedException: when closing handshake was
+                not successfull.
+        """
+
+        if self._request.server_terminated:
+            self._logger.debug(
+                'Requested close_connection but server is already terminated')
+            return
+
+        if not self._enable_closing_handshake:
+            self._request.server_terminated = True
+            self._logger.debug('Connection closed')
+            return
+
+        self._send_closing_handshake()
+        self._logger.debug('Sent server-initiated closing handshake')
+
+        # TODO(ukai): 2. wait until the /client terminated/ flag has been set,
+        # or until a server-defined timeout expires.
+        #
+        # For now, we expect receiving closing handshake right after sending
+        # out closing handshake, and if we couldn't receive non-handshake
+        # frame, we take it as ConnectionTerminatedException.
+        message = self.receive_message()
+        if message is not None:
+            raise ConnectionTerminatedException(
+                'Didn\'t receive valid ack for closing handshake')
+        # TODO: 3. close the WebSocket connection.
+        # note: mod_python Connection (mp_conn) doesn't have close method.
+
+    def send_ping(self, body):
+        raise BadOperationException(
+            'StreamHixie75 doesn\'t support send_ping')
+
+
+# vi:sts=4 sw=4 et
diff --git a/module/lib/mod_pywebsocket/_stream_hybi.py b/module/lib/mod_pywebsocket/_stream_hybi.py
new file mode 100644
index 000000000..bd158fa6b
--- /dev/null
+++ b/module/lib/mod_pywebsocket/_stream_hybi.py
@@ -0,0 +1,915 @@
+# Copyright 2012, Google Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+"""This file provides classes and helper functions for parsing/building frames
+of the WebSocket protocol (RFC 6455).
+
+Specification:
+http://tools.ietf.org/html/rfc6455
+"""
+
+
+from collections import deque
+import logging
+import os
+import struct
+import time
+
+from mod_pywebsocket import common
+from mod_pywebsocket import util
+from mod_pywebsocket._stream_base import BadOperationException
+from mod_pywebsocket._stream_base import ConnectionTerminatedException
+from mod_pywebsocket._stream_base import InvalidFrameException
+from mod_pywebsocket._stream_base import InvalidUTF8Exception
+from mod_pywebsocket._stream_base import StreamBase
+from mod_pywebsocket._stream_base import UnsupportedFrameException
+
+
+_NOOP_MASKER = util.NoopMasker()
+
+
+class Frame(object):
+
+    def __init__(self, fin=1, rsv1=0, rsv2=0, rsv3=0,
+                 opcode=None, payload=''):
+        self.fin = fin
+        self.rsv1 = rsv1
+        self.rsv2 = rsv2
+        self.rsv3 = rsv3
+        self.opcode = opcode
+        self.payload = payload
+
+
+# Helper functions made public to be used for writing unittests for WebSocket
+# clients.
+
+
+def create_length_header(length, mask):
+    """Creates a length header.
+
+    Args:
+        length: Frame length. Must be less than 2^63.
+        mask: Mask bit. Must be boolean.
+
+    Raises:
+        ValueError: when bad data is given.
+    """
+
+    if mask:
+        mask_bit = 1 << 7
+    else:
+        mask_bit = 0
+
+    if length < 0:
+        raise ValueError('length must be non negative integer')
+    elif length <= 125:
+        return chr(mask_bit | length)
+    elif length < (1 << 16):
+        return chr(mask_bit | 126) + struct.pack('!H', length)
+    elif length < (1 << 63):
+        return chr(mask_bit | 127) + struct.pack('!Q', length)
+    else:
+        raise ValueError('Payload is too big for one frame')
+
+
+def create_header(opcode, payload_length, fin, rsv1, rsv2, rsv3, mask):
+    """Creates a frame header.
+
+    Raises:
+        Exception: when bad data is given.
+    """
+
+    if opcode < 0 or 0xf < opcode:
+        raise ValueError('Opcode out of range')
+
+    if payload_length < 0 or (1 << 63) <= payload_length:
+        raise ValueError('payload_length out of range')
+
+    if (fin | rsv1 | rsv2 | rsv3) & ~1:
+        raise ValueError('FIN bit and Reserved bit parameter must be 0 or 1')
+
+    header = ''
+
+    first_byte = ((fin << 7)
+                  | (rsv1 << 6) | (rsv2 << 5) | (rsv3 << 4)
+                  | opcode)
+    header += chr(first_byte)
+    header += create_length_header(payload_length, mask)
+
+    return header
+
+
+def _build_frame(header, body, mask):
+    if not mask:
+        return header + body
+
+    masking_nonce = os.urandom(4)
+    masker = util.RepeatedXorMasker(masking_nonce)
+
+    return header + masking_nonce + masker.mask(body)
+
+
+def _filter_and_format_frame_object(frame, mask, frame_filters):
+    for frame_filter in frame_filters:
+        frame_filter.filter(frame)
+
+    header = create_header(
+        frame.opcode, len(frame.payload), frame.fin,
+        frame.rsv1, frame.rsv2, frame.rsv3, mask)
+    return _build_frame(header, frame.payload, mask)
+
+
+def create_binary_frame(
+    message, opcode=common.OPCODE_BINARY, fin=1, mask=False, frame_filters=[]):
+    """Creates a simple binary frame with no extension, reserved bit."""
+
+    frame = Frame(fin=fin, opcode=opcode, payload=message)
+    return _filter_and_format_frame_object(frame, mask, frame_filters)
+
+
+def create_text_frame(
+    message, opcode=common.OPCODE_TEXT, fin=1, mask=False, frame_filters=[]):
+    """Creates a simple text frame with no extension, reserved bit."""
+
+    encoded_message = message.encode('utf-8')
+    return create_binary_frame(encoded_message, opcode, fin, mask,
+                               frame_filters)
+
+
+def parse_frame(receive_bytes, logger=None,
+                ws_version=common.VERSION_HYBI_LATEST,
+                unmask_receive=True):
+    """Parses a frame. Returns a tuple containing each header field and
+    payload.
+
+    Args:
+        receive_bytes: a function that reads frame data from a stream or
+            something similar. The function takes length of the bytes to be
+            read. The function must raise ConnectionTerminatedException if
+            there is not enough data to be read.
+        logger: a logging object.
+        ws_version: the version of WebSocket protocol.
+        unmask_receive: unmask received frames. When received unmasked
+            frame, raises InvalidFrameException.
+
+    Raises:
+        ConnectionTerminatedException: when receive_bytes raises it.
+        InvalidFrameException: when the frame contains invalid data.
+    """
+
+    if not logger:
+        logger = logging.getLogger()
+
+    logger.log(common.LOGLEVEL_FINE, 'Receive the first 2 octets of a frame')
+
+    received = receive_bytes(2)
+
+    first_byte = ord(received[0])
+    fin = (first_byte >> 7) & 1
+    rsv1 = (first_byte >> 6) & 1
+    rsv2 = (first_byte >> 5) & 1
+    rsv3 = (first_byte >> 4) & 1
+    opcode = first_byte & 0xf
+
+    second_byte = ord(received[1])
+    mask = (second_byte >> 7) & 1
+    payload_length = second_byte & 0x7f
+
+    logger.log(common.LOGLEVEL_FINE,
+               'FIN=%s, RSV1=%s, RSV2=%s, RSV3=%s, opcode=%s, '
+               'Mask=%s, Payload_length=%s',
+               fin, rsv1, rsv2, rsv3, opcode, mask, payload_length)
+
+    if (mask == 1) != unmask_receive:
+        raise InvalidFrameException(
+            'Mask bit on the received frame did\'nt match masking '
+            'configuration for received frames')
+
+    # The HyBi and later specs disallow putting a value in 0x0-0xFFFF
+    # into the 8-octet extended payload length field (or 0x0-0xFD in
+    # 2-octet field).
+    valid_length_encoding = True
+    length_encoding_bytes = 1
+    if payload_length == 127:
+        logger.log(common.LOGLEVEL_FINE,
+                   'Receive 8-octet extended payload length')
+
+        extended_payload_length = receive_bytes(8)
+        payload_length = struct.unpack(
+            '!Q', extended_payload_length)[0]
+        if payload_length > 0x7FFFFFFFFFFFFFFF:
+            raise InvalidFrameException(
+                'Extended payload length >= 2^63')
+        if ws_version >= 13 and payload_length < 0x10000:
+            valid_length_encoding = False
+            length_encoding_bytes = 8
+
+        logger.log(common.LOGLEVEL_FINE,
+                   'Decoded_payload_length=%s', payload_length)
+    elif payload_length == 126:
+        logger.log(common.LOGLEVEL_FINE,
+                   'Receive 2-octet extended payload length')
+
+        extended_payload_length = receive_bytes(2)
+        payload_length = struct.unpack(
+            '!H', extended_payload_length)[0]
+        if ws_version >= 13 and payload_length < 126:
+            valid_length_encoding = False
+            length_encoding_bytes = 2
+
+        logger.log(common.LOGLEVEL_FINE,
+                   'Decoded_payload_length=%s', payload_length)
+
+    if not valid_length_encoding:
+        logger.warning(
+            'Payload length is not encoded using the minimal number of '
+            'bytes (%d is encoded using %d bytes)',
+            payload_length,
+            length_encoding_bytes)
+
+    if mask == 1:
+        logger.log(common.LOGLEVEL_FINE, 'Receive mask')
+
+        masking_nonce = receive_bytes(4)
+        masker = util.RepeatedXorMasker(masking_nonce)
+
+        logger.log(common.LOGLEVEL_FINE, 'Mask=%r', masking_nonce)
+    else:
+        masker = _NOOP_MASKER
+
+    logger.log(common.LOGLEVEL_FINE, 'Receive payload data')
+    if logger.isEnabledFor(common.LOGLEVEL_FINE):
+        receive_start = time.time()
+
+    raw_payload_bytes = receive_bytes(payload_length)
+
+    if logger.isEnabledFor(common.LOGLEVEL_FINE):
+        logger.log(
+            common.LOGLEVEL_FINE,
+            'Done receiving payload data at %s MB/s',
+            payload_length / (time.time() - receive_start) / 1000 / 1000)
+    logger.log(common.LOGLEVEL_FINE, 'Unmask payload data')
+
+    if logger.isEnabledFor(common.LOGLEVEL_FINE):
+        unmask_start = time.time()
+
+    bytes = masker.mask(raw_payload_bytes)
+
+    if logger.isEnabledFor(common.LOGLEVEL_FINE):
+        logger.log(
+            common.LOGLEVEL_FINE,
+            'Done unmasking payload data at %s MB/s',
+            payload_length / (time.time() - unmask_start) / 1000 / 1000)
+
+    return opcode, bytes, fin, rsv1, rsv2, rsv3
+
+
+class FragmentedFrameBuilder(object):
+    """A stateful class to send a message as fragments."""
+
+    def __init__(self, mask, frame_filters=[], encode_utf8=True):
+        """Constructs an instance."""
+
+        self._mask = mask
+        self._frame_filters = frame_filters
+        # This is for skipping UTF-8 encoding when building text type frames
+        # from compressed data.
+        self._encode_utf8 = encode_utf8
+
+        self._started = False
+
+        # Hold opcode of the first frame in messages to verify types of other
+        # frames in the message are all the same.
+        self._opcode = common.OPCODE_TEXT
+
+    def build(self, payload_data, end, binary):
+        if binary:
+            frame_type = common.OPCODE_BINARY
+        else:
+            frame_type = common.OPCODE_TEXT
+        if self._started:
+            if self._opcode != frame_type:
+                raise ValueError('Message types are different in frames for '
+                                 'the same message')
+            opcode = common.OPCODE_CONTINUATION
+        else:
+            opcode = frame_type
+            self._opcode = frame_type
+
+        if end:
+            self._started = False
+            fin = 1
+        else:
+            self._started = True
+            fin = 0
+
+        if binary or not self._encode_utf8:
+            return create_binary_frame(
+                payload_data, opcode, fin, self._mask, self._frame_filters)
+        else:
+            return create_text_frame(
+                payload_data, opcode, fin, self._mask, self._frame_filters)
+
+
+def _create_control_frame(opcode, body, mask, frame_filters):
+    frame = Frame(opcode=opcode, payload=body)
+
+    for frame_filter in frame_filters:
+        frame_filter.filter(frame)
+
+    if len(frame.payload) > 125:
+        raise BadOperationException(
+            'Payload data size of control frames must be 125 bytes or less')
+
+    header = create_header(
+        frame.opcode, len(frame.payload), frame.fin,
+        frame.rsv1, frame.rsv2, frame.rsv3, mask)
+    return _build_frame(header, frame.payload, mask)
+
+
+def create_ping_frame(body, mask=False, frame_filters=[]):
+    return _create_control_frame(common.OPCODE_PING, body, mask, frame_filters)
+
+
+def create_pong_frame(body, mask=False, frame_filters=[]):
+    return _create_control_frame(common.OPCODE_PONG, body, mask, frame_filters)
+
+
+def create_close_frame(body, mask=False, frame_filters=[]):
+    return _create_control_frame(
+        common.OPCODE_CLOSE, body, mask, frame_filters)
+
+
+def create_closing_handshake_body(code, reason):
+    body = ''
+    if code is not None:
+        if (code > common.STATUS_USER_PRIVATE_MAX or
+            code < common.STATUS_NORMAL_CLOSURE):
+            raise BadOperationException('Status code is out of range')
+        if (code == common.STATUS_NO_STATUS_RECEIVED or
+            code == common.STATUS_ABNORMAL_CLOSURE or
+            code == common.STATUS_TLS_HANDSHAKE):
+            raise BadOperationException('Status code is reserved pseudo '
+                'code')
+        encoded_reason = reason.encode('utf-8')
+        body = struct.pack('!H', code) + encoded_reason
+    return body
+
+
+class StreamOptions(object):
+    """Holds option values to configure Stream objects."""
+
+    def __init__(self):
+        """Constructs StreamOptions."""
+
+        # Enables deflate-stream extension.
+        self.deflate_stream = False
+
+        # Filters applied to frames.
+        self.outgoing_frame_filters = []
+        self.incoming_frame_filters = []
+
+        # Filters applied to messages. Control frames are not affected by them.
+        self.outgoing_message_filters = []
+        self.incoming_message_filters = []
+
+        self.encode_text_message_to_utf8 = True
+        self.mask_send = False
+        self.unmask_receive = True
+        # RFC6455 disallows fragmented control frames, but mux extension
+        # relaxes the restriction.
+        self.allow_fragmented_control_frame = False
+
+
+class Stream(StreamBase):
+    """A class for parsing/building frames of the WebSocket protocol
+    (RFC 6455).
+    """
+
+    def __init__(self, request, options):
+        """Constructs an instance.
+
+        Args:
+            request: mod_python request.
+        """
+
+        StreamBase.__init__(self, request)
+
+        self._logger = util.get_class_logger(self)
+
+        self._options = options
+
+        if self._options.deflate_stream:
+            self._logger.debug('Setup filter for deflate-stream')
+            self._request = util.DeflateRequest(self._request)
+
+        self._request.client_terminated = False
+        self._request.server_terminated = False
+
+        # Holds body of received fragments.
+        self._received_fragments = []
+        # Holds the opcode of the first fragment.
+        self._original_opcode = None
+
+        self._writer = FragmentedFrameBuilder(
+            self._options.mask_send, self._options.outgoing_frame_filters,
+            self._options.encode_text_message_to_utf8)
+
+        self._ping_queue = deque()
+
+    def _receive_frame(self):
+        """Receives a frame and return data in the frame as a tuple containing
+        each header field and payload separately.
+
+        Raises:
+            ConnectionTerminatedException: when read returns empty
+                string.
+            InvalidFrameException: when the frame contains invalid data.
+        """
+
+        def _receive_bytes(length):
+            return self.receive_bytes(length)
+
+        return parse_frame(receive_bytes=_receive_bytes,
+                           logger=self._logger,
+                           ws_version=self._request.ws_version,
+                           unmask_receive=self._options.unmask_receive)
+
+    def _receive_frame_as_frame_object(self):
+        opcode, bytes, fin, rsv1, rsv2, rsv3 = self._receive_frame()
+
+        return Frame(fin=fin, rsv1=rsv1, rsv2=rsv2, rsv3=rsv3,
+                     opcode=opcode, payload=bytes)
+
+    def receive_filtered_frame(self):
+        """Receives a frame and applies frame filters and message filters.
+        The frame to be received must satisfy following conditions:
+        - The frame is not fragmented.
+        - The opcode of the frame is TEXT or BINARY.
+
+        DO NOT USE this method except for testing purpose.
+        """
+
+        frame = self._receive_frame_as_frame_object()
+        if not frame.fin:
+            raise InvalidFrameException(
+                'Segmented frames must not be received via '
+                'receive_filtered_frame()')
+        if (frame.opcode != common.OPCODE_TEXT and
+            frame.opcode != common.OPCODE_BINARY):
+            raise InvalidFrameException(
+                'Control frames must not be received via '
+                'receive_filtered_frame()')
+
+        for frame_filter in self._options.incoming_frame_filters:
+            frame_filter.filter(frame)
+        for message_filter in self._options.incoming_message_filters:
+            frame.payload = message_filter.filter(frame.payload)
+        return frame
+
+    def send_message(self, message, end=True, binary=False):
+        """Send message.
+
+        Args:
+            message: text in unicode or binary in str to send.
+            binary: send message as binary frame.
+
+        Raises:
+            BadOperationException: when called on a server-terminated
+                connection or called with inconsistent message type or
+                binary parameter.
+        """
+
+        if self._request.server_terminated:
+            raise BadOperationException(
+                'Requested send_message after sending out a closing handshake')
+
+        if binary and isinstance(message, unicode):
+            raise BadOperationException(
+                'Message for binary frame must be instance of str')
+
+        for message_filter in self._options.outgoing_message_filters:
+            message = message_filter.filter(message, end, binary)
+
+        try:
+            # Set this to any positive integer to limit maximum size of data in
+            # payload data of each frame.
+            MAX_PAYLOAD_DATA_SIZE = -1
+
+            if MAX_PAYLOAD_DATA_SIZE <= 0:
+                self._write(self._writer.build(message, end, binary))
+                return
+
+            bytes_written = 0
+            while True:
+                end_for_this_frame = end
+                bytes_to_write = len(message) - bytes_written
+                if (MAX_PAYLOAD_DATA_SIZE > 0 and
+                    bytes_to_write > MAX_PAYLOAD_DATA_SIZE):
+                    end_for_this_frame = False
+                    bytes_to_write = MAX_PAYLOAD_DATA_SIZE
+
+                frame = self._writer.build(
+                    message[bytes_written:bytes_written + bytes_to_write],
+                    end_for_this_frame,
+                    binary)
+                self._write(frame)
+
+                bytes_written += bytes_to_write
+
+                # This if must be placed here (the end of while block) so that
+                # at least one frame is sent.
+                if len(message) <= bytes_written:
+                    break
+        except ValueError, e:
+            raise BadOperationException(e)
+
+    def _get_message_from_frame(self, frame):
+        """Gets a message from frame. If the message is composed of fragmented
+        frames and the frame is not the last fragmented frame, this method
+        returns None. The whole message will be returned when the last
+        fragmented frame is passed to this method.
+
+        Raises:
+            InvalidFrameException: when the frame doesn't match defragmentation
+                context, or the frame contains invalid data.
+        """
+
+        if frame.opcode == common.OPCODE_CONTINUATION:
+            if not self._received_fragments:
+                if frame.fin:
+                    raise InvalidFrameException(
+                        'Received a termination frame but fragmentation '
+                        'not started')
+                else:
+                    raise InvalidFrameException(
+                        'Received an intermediate frame but '
+                        'fragmentation not started')
+
+            if frame.fin:
+                # End of fragmentation frame
+                self._received_fragments.append(frame.payload)
+                message = ''.join(self._received_fragments)
+                self._received_fragments = []
+                return message
+            else:
+                # Intermediate frame
+                self._received_fragments.append(frame.payload)
+                return None
+        else:
+            if self._received_fragments:
+                if frame.fin:
+                    raise InvalidFrameException(
+                        'Received an unfragmented frame without '
+                        'terminating existing fragmentation')
+                else:
+                    raise InvalidFrameException(
+                        'New fragmentation started without terminating '
+                        'existing fragmentation')
+
+            if frame.fin:
+                # Unfragmented frame
+
+                self._original_opcode = frame.opcode
+                return frame.payload
+            else:
+                # Start of fragmentation frame
+
+                if (not self._options.allow_fragmented_control_frame and
+                    common.is_control_opcode(frame.opcode)):
+                    raise InvalidFrameException(
+                        'Control frames must not be fragmented')
+
+                self._original_opcode = frame.opcode
+                self._received_fragments.append(frame.payload)
+                return None
+
+    def _process_close_message(self, message):
+        """Processes close message.
+
+        Args:
+            message: close message.
+
+        Raises:
+            InvalidFrameException: when the message is invalid.
+        """
+
+        self._request.client_terminated = True
+
+        # Status code is optional. We can have status reason only if we
+        # have status code. Status reason can be empty string. So,
+        # allowed cases are
+        # - no application data: no code no reason
+        # - 2 octet of application data: has code but no reason
+        # - 3 or more octet of application data: both code and reason
+        if len(message) == 0:
+            self._logger.debug('Received close frame (empty body)')
+            self._request.ws_close_code = (
+                common.STATUS_NO_STATUS_RECEIVED)
+        elif len(message) == 1:
+            raise InvalidFrameException(
+                'If a close frame has status code, the length of '
+                'status code must be 2 octet')
+        elif len(message) >= 2:
+            self._request.ws_close_code = struct.unpack(
+                '!H', message[0:2])[0]
+            self._request.ws_close_reason = message[2:].decode(
+                'utf-8', 'replace')
+            self._logger.debug(
+                'Received close frame (code=%d, reason=%r)',
+                self._request.ws_close_code,
+                self._request.ws_close_reason)
+
+        # Drain junk data after the close frame if necessary.
+        self._drain_received_data()
+
+        if self._request.server_terminated:
+            self._logger.debug(
+                'Received ack for server-initiated closing handshake')
+            return
+
+        self._logger.debug(
+            'Received client-initiated closing handshake')
+
+        code = common.STATUS_NORMAL_CLOSURE
+        reason = ''
+        if hasattr(self._request, '_dispatcher'):
+            dispatcher = self._request._dispatcher
+            code, reason = dispatcher.passive_closing_handshake(
+                self._request)
+            if code is None and reason is not None and len(reason) > 0:
+                self._logger.warning(
+                    'Handler specified reason despite code being None')
+                reason = ''
+            if reason is None:
+                reason = ''
+        self._send_closing_handshake(code, reason)
+        self._logger.debug(
+            'Sent ack for client-initiated closing handshake '
+            '(code=%r, reason=%r)', code, reason)
+
+    def _process_ping_message(self, message):
+        """Processes ping message.
+
+        Args:
+            message: ping message.
+        """
+
+        try:
+            handler = self._request.on_ping_handler
+            if handler:
+                handler(self._request, message)
+                return
+        except AttributeError, e:
+            pass
+        self._send_pong(message)
+
+    def _process_pong_message(self, message):
+        """Processes pong message.
+
+        Args:
+            message: pong message.
+        """
+
+        # TODO(tyoshino): Add ping timeout handling.
+
+        inflight_pings = deque()
+
+        while True:
+            try:
+                expected_body = self._ping_queue.popleft()
+                if expected_body == message:
+                    # inflight_pings contains pings ignored by the
+                    # other peer. Just forget them.
+                    self._logger.debug(
+                        'Ping %r is acked (%d pings were ignored)',
+                        expected_body, len(inflight_pings))
+                    break
+                else:
+                    inflight_pings.append(expected_body)
+            except IndexError, e:
+                # The received pong was unsolicited pong. Keep the
+                # ping queue as is.
+                self._ping_queue = inflight_pings
+                self._logger.debug('Received a unsolicited pong')
+                break
+
+        try:
+            handler = self._request.on_pong_handler
+            if handler:
+                handler(self._request, message)
+        except AttributeError, e:
+            pass
+
+    def receive_message(self):
+        """Receive a WebSocket frame and return its payload as a text in
+        unicode or a binary in str.
+
+        Returns:
+            payload data of the frame
+            - as unicode instance if received text frame
+            - as str instance if received binary frame
+            or None iff received closing handshake.
+        Raises:
+            BadOperationException: when called on a client-terminated
+                connection.
+            ConnectionTerminatedException: when read returns empty
+                string.
+            InvalidFrameException: when the frame contains invalid
+                data.
+            UnsupportedFrameException: when the received frame has
+                flags, opcode we cannot handle. You can ignore this
+                exception and continue receiving the next frame.
+        """
+
+        if self._request.client_terminated:
+            raise BadOperationException(
+                'Requested receive_message after receiving a closing '
+                'handshake')
+
+        while True:
+            # mp_conn.read will block if no bytes are available.
+            # Timeout is controlled by TimeOut directive of Apache.
+
+            frame = self._receive_frame_as_frame_object()
+
+            # Check the constraint on the payload size for control frames
+            # before extension processes the frame.
+            # See also http://tools.ietf.org/html/rfc6455#section-5.5
+            if (common.is_control_opcode(frame.opcode) and
+                len(frame.payload) > 125):
+                raise InvalidFrameException(
+                    'Payload data size of control frames must be 125 bytes or '
+                    'less')
+
+            for frame_filter in self._options.incoming_frame_filters:
+                frame_filter.filter(frame)
+
+            if frame.rsv1 or frame.rsv2 or frame.rsv3:
+                raise UnsupportedFrameException(
+                    'Unsupported flag is set (rsv = %d%d%d)' %
+                    (frame.rsv1, frame.rsv2, frame.rsv3))
+
+            message = self._get_message_from_frame(frame)
+            if message is None:
+                continue
+
+            for message_filter in self._options.incoming_message_filters:
+                message = message_filter.filter(message)
+
+            if self._original_opcode == common.OPCODE_TEXT:
+                # The WebSocket protocol section 4.4 specifies that invalid
+                # characters must be replaced with U+fffd REPLACEMENT
+                # CHARACTER.
+                try:
+                    return message.decode('utf-8')
+                except UnicodeDecodeError, e:
+                    raise InvalidUTF8Exception(e)
+            elif self._original_opcode == common.OPCODE_BINARY:
+                return message
+            elif self._original_opcode == common.OPCODE_CLOSE:
+                self._process_close_message(message)
+                return None
+            elif self._original_opcode == common.OPCODE_PING:
+                self._process_ping_message(message)
+            elif self._original_opcode == common.OPCODE_PONG:
+                self._process_pong_message(message)
+            else:
+                raise UnsupportedFrameException(
+                    'Opcode %d is not supported' % self._original_opcode)
+
+    def _send_closing_handshake(self, code, reason):
+        body = create_closing_handshake_body(code, reason)
+        frame = create_close_frame(
+            body, mask=self._options.mask_send,
+            frame_filters=self._options.outgoing_frame_filters)
+
+        self._request.server_terminated = True
+
+        self._write(frame)
+
+    def close_connection(self, code=common.STATUS_NORMAL_CLOSURE, reason=''):
+        """Closes a WebSocket connection.
+
+        Args:
+            code: Status code for close frame. If code is None, a close
+                frame with empty body will be sent.
+            reason: string representing close reason.
+        Raises:
+            BadOperationException: when reason is specified with code None
+            or reason is not an instance of both str and unicode.
+        """
+
+        if self._request.server_terminated:
+            self._logger.debug(
+                'Requested close_connection but server is already terminated')
+            return
+
+        if code is None:
+            if reason is not None and len(reason) > 0:
+                raise BadOperationException(
+                    'close reason must not be specified if code is None')
+            reason = ''
+        else:
+            if not isinstance(reason, str) and not isinstance(reason, unicode):
+                raise BadOperationException(
+                    'close reason must be an instance of str or unicode')
+
+        self._send_closing_handshake(code, reason)
+        self._logger.debug(
+            'Sent server-initiated closing handshake (code=%r, reason=%r)',
+            code, reason)
+
+        if (code == common.STATUS_GOING_AWAY or
+            code == common.STATUS_PROTOCOL_ERROR):
+            # It doesn't make sense to wait for a close frame if the reason is
+            # protocol error or that the server is going away. For some of
+            # other reasons, it might not make sense to wait for a close frame,
+            # but it's not clear, yet.
+            return
+
+        # TODO(ukai): 2. wait until the /client terminated/ flag has been set,
+        # or until a server-defined timeout expires.
+        #
+        # For now, we expect receiving closing handshake right after sending
+        # out closing handshake.
+        message = self.receive_message()
+        if message is not None:
+            raise ConnectionTerminatedException(
+                'Didn\'t receive valid ack for closing handshake')
+        # TODO: 3. close the WebSocket connection.
+        # note: mod_python Connection (mp_conn) doesn't have close method.
+
+    def send_ping(self, body=''):
+        frame = create_ping_frame(
+            body,
+            self._options.mask_send,
+            self._options.outgoing_frame_filters)
+        self._write(frame)
+
+        self._ping_queue.append(body)
+
+    def _send_pong(self, body):
+        frame = create_pong_frame(
+            body,
+            self._options.mask_send,
+            self._options.outgoing_frame_filters)
+        self._write(frame)
+
+    def get_last_received_opcode(self):
+        """Returns the opcode of the WebSocket message which the last received
+        frame belongs to. The return value is valid iff immediately after
+        receive_message call.
+        """
+
+        return self._original_opcode
+
+    def _drain_received_data(self):
+        """Drains unread data in the receive buffer to avoid sending out TCP
+        RST packet. This is because when deflate-stream is enabled, some
+        DEFLATE block for flushing data may follow a close frame. If any data
+        remains in the receive buffer of a socket when the socket is closed,
+        it sends out TCP RST packet to the other peer.
+
+        Since mod_python's mp_conn object doesn't support non-blocking read,
+        we perform this only when pywebsocket is running in standalone mode.
+        """
+
+        # If self._options.deflate_stream is true, self._request is
+        # DeflateRequest, so we can get wrapped request object by
+        # self._request._request.
+        #
+        # Only _StandaloneRequest has _drain_received_data method.
+        if (self._options.deflate_stream and
+            ('_drain_received_data' in dir(self._request._request))):
+            self._request._request._drain_received_data()
+
+
+# vi:sts=4 sw=4 et
diff --git a/module/lib/mod_pywebsocket/common.py b/module/lib/mod_pywebsocket/common.py
new file mode 100644
index 000000000..2388379c0
--- /dev/null
+++ b/module/lib/mod_pywebsocket/common.py
@@ -0,0 +1,307 @@
+# Copyright 2012, Google Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+"""This file must not depend on any module specific to the WebSocket protocol.
+"""
+
+
+from mod_pywebsocket import http_header_util
+
+
+# Additional log level definitions.
+LOGLEVEL_FINE = 9
+
+# Constants indicating WebSocket protocol version.
+VERSION_HIXIE75 = -1
+VERSION_HYBI00 = 0
+VERSION_HYBI01 = 1
+VERSION_HYBI02 = 2
+VERSION_HYBI03 = 2
+VERSION_HYBI04 = 4
+VERSION_HYBI05 = 5
+VERSION_HYBI06 = 6
+VERSION_HYBI07 = 7
+VERSION_HYBI08 = 8
+VERSION_HYBI09 = 8
+VERSION_HYBI10 = 8
+VERSION_HYBI11 = 8
+VERSION_HYBI12 = 8
+VERSION_HYBI13 = 13
+VERSION_HYBI14 = 13
+VERSION_HYBI15 = 13
+VERSION_HYBI16 = 13
+VERSION_HYBI17 = 13
+
+# Constants indicating WebSocket protocol latest version.
+VERSION_HYBI_LATEST = VERSION_HYBI13
+
+# Port numbers
+DEFAULT_WEB_SOCKET_PORT = 80
+DEFAULT_WEB_SOCKET_SECURE_PORT = 443
+
+# Schemes
+WEB_SOCKET_SCHEME = 'ws'
+WEB_SOCKET_SECURE_SCHEME = 'wss'
+
+# Frame opcodes defined in the spec.
+OPCODE_CONTINUATION = 0x0
+OPCODE_TEXT = 0x1
+OPCODE_BINARY = 0x2
+OPCODE_CLOSE = 0x8
+OPCODE_PING = 0x9
+OPCODE_PONG = 0xa
+
+# UUIDs used by HyBi 04 and later opening handshake and frame masking.
+WEBSOCKET_ACCEPT_UUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
+
+# Opening handshake header names and expected values.
+UPGRADE_HEADER = 'Upgrade'
+WEBSOCKET_UPGRADE_TYPE = 'websocket'
+WEBSOCKET_UPGRADE_TYPE_HIXIE75 = 'WebSocket'
+CONNECTION_HEADER = 'Connection'
+UPGRADE_CONNECTION_TYPE = 'Upgrade'
+HOST_HEADER = 'Host'
+ORIGIN_HEADER = 'Origin'
+SEC_WEBSOCKET_ORIGIN_HEADER = 'Sec-WebSocket-Origin'
+SEC_WEBSOCKET_KEY_HEADER = 'Sec-WebSocket-Key'
+SEC_WEBSOCKET_ACCEPT_HEADER = 'Sec-WebSocket-Accept'
+SEC_WEBSOCKET_VERSION_HEADER = 'Sec-WebSocket-Version'
+SEC_WEBSOCKET_PROTOCOL_HEADER = 'Sec-WebSocket-Protocol'
+SEC_WEBSOCKET_EXTENSIONS_HEADER = 'Sec-WebSocket-Extensions'
+SEC_WEBSOCKET_DRAFT_HEADER = 'Sec-WebSocket-Draft'
+SEC_WEBSOCKET_KEY1_HEADER = 'Sec-WebSocket-Key1'
+SEC_WEBSOCKET_KEY2_HEADER = 'Sec-WebSocket-Key2'
+SEC_WEBSOCKET_LOCATION_HEADER = 'Sec-WebSocket-Location'
+
+# Extensions
+DEFLATE_STREAM_EXTENSION = 'deflate-stream'
+DEFLATE_FRAME_EXTENSION = 'deflate-frame'
+PERFRAME_COMPRESSION_EXTENSION = 'perframe-compress'
+PERMESSAGE_COMPRESSION_EXTENSION = 'permessage-compress'
+X_WEBKIT_DEFLATE_FRAME_EXTENSION = 'x-webkit-deflate-frame'
+X_WEBKIT_PERMESSAGE_COMPRESSION_EXTENSION = 'x-webkit-permessage-compress'
+MUX_EXTENSION = 'mux_DO_NOT_USE'
+
+# Status codes
+# Code STATUS_NO_STATUS_RECEIVED, STATUS_ABNORMAL_CLOSURE, and
+# STATUS_TLS_HANDSHAKE are pseudo codes to indicate specific error cases.
+# Could not be used for codes in actual closing frames.
+# Application level errors must use codes in the range
+# STATUS_USER_REGISTERED_BASE to STATUS_USER_PRIVATE_MAX. The codes in the
+# range STATUS_USER_REGISTERED_BASE to STATUS_USER_REGISTERED_MAX are managed
+# by IANA. Usually application must define user protocol level errors in the
+# range STATUS_USER_PRIVATE_BASE to STATUS_USER_PRIVATE_MAX.
+STATUS_NORMAL_CLOSURE = 1000
+STATUS_GOING_AWAY = 1001
+STATUS_PROTOCOL_ERROR = 1002
+STATUS_UNSUPPORTED_DATA = 1003
+STATUS_NO_STATUS_RECEIVED = 1005
+STATUS_ABNORMAL_CLOSURE = 1006
+STATUS_INVALID_FRAME_PAYLOAD_DATA = 1007
+STATUS_POLICY_VIOLATION = 1008
+STATUS_MESSAGE_TOO_BIG = 1009
+STATUS_MANDATORY_EXTENSION = 1010
+STATUS_INTERNAL_ENDPOINT_ERROR = 1011
+STATUS_TLS_HANDSHAKE = 1015
+STATUS_USER_REGISTERED_BASE = 3000
+STATUS_USER_REGISTERED_MAX = 3999
+STATUS_USER_PRIVATE_BASE = 4000
+STATUS_USER_PRIVATE_MAX = 4999
+# Following definitions are aliases to keep compatibility. Applications must
+# not use these obsoleted definitions anymore.
+STATUS_NORMAL = STATUS_NORMAL_CLOSURE
+STATUS_UNSUPPORTED = STATUS_UNSUPPORTED_DATA
+STATUS_CODE_NOT_AVAILABLE = STATUS_NO_STATUS_RECEIVED
+STATUS_ABNORMAL_CLOSE = STATUS_ABNORMAL_CLOSURE
+STATUS_INVALID_FRAME_PAYLOAD = STATUS_INVALID_FRAME_PAYLOAD_DATA
+STATUS_MANDATORY_EXT = STATUS_MANDATORY_EXTENSION
+
+# HTTP status codes
+HTTP_STATUS_BAD_REQUEST = 400
+HTTP_STATUS_FORBIDDEN = 403
+HTTP_STATUS_NOT_FOUND = 404
+
+
+def is_control_opcode(opcode):
+    return (opcode >> 3) == 1
+
+
+class ExtensionParameter(object):
+    """Holds information about an extension which is exchanged on extension
+    negotiation in opening handshake.
+    """
+
+    def __init__(self, name):
+        self._name = name
+        # TODO(tyoshino): Change the data structure to more efficient one such
+        # as dict when the spec changes to say like
+        # - Parameter names must be unique
+        # - The order of parameters is not significant
+        self._parameters = []
+
+    def name(self):
+        return self._name
+
+    def add_parameter(self, name, value):
+        self._parameters.append((name, value))
+
+    def get_parameters(self):
+        return self._parameters
+
+    def get_parameter_names(self):
+        return [name for name, unused_value in self._parameters]
+
+    def has_parameter(self, name):
+        for param_name, param_value in self._parameters:
+            if param_name == name:
+                return True
+        return False
+
+    def get_parameter_value(self, name):
+        for param_name, param_value in self._parameters:
+            if param_name == name:
+                return param_value
+
+
+class ExtensionParsingException(Exception):
+    def __init__(self, name):
+        super(ExtensionParsingException, self).__init__(name)
+
+
+def _parse_extension_param(state, definition, allow_quoted_string):
+    param_name = http_header_util.consume_token(state)
+
+    if param_name is None:
+        raise ExtensionParsingException('No valid parameter name found')
+
+    http_header_util.consume_lwses(state)
+
+    if not http_header_util.consume_string(state, '='):
+        definition.add_parameter(param_name, None)
+        return
+
+    http_header_util.consume_lwses(state)
+
+    if allow_quoted_string:
+        # TODO(toyoshim): Add code to validate that parsed param_value is token
+        param_value = http_header_util.consume_token_or_quoted_string(state)
+    else:
+        param_value = http_header_util.consume_token(state)
+    if param_value is None:
+        raise ExtensionParsingException(
+            'No valid parameter value found on the right-hand side of '
+            'parameter %r' % param_name)
+
+    definition.add_parameter(param_name, param_value)
+
+
+def _parse_extension(state, allow_quoted_string):
+    extension_token = http_header_util.consume_token(state)
+    if extension_token is None:
+        return None
+
+    extension = ExtensionParameter(extension_token)
+
+    while True:
+        http_header_util.consume_lwses(state)
+
+        if not http_header_util.consume_string(state, ';'):
+            break
+
+        http_header_util.consume_lwses(state)
+
+        try:
+            _parse_extension_param(state, extension, allow_quoted_string)
+        except ExtensionParsingException, e:
+            raise ExtensionParsingException(
+                'Failed to parse parameter for %r (%r)' %
+                (extension_token, e))
+
+    return extension
+
+
+def parse_extensions(data, allow_quoted_string=False):
+    """Parses Sec-WebSocket-Extensions header value returns a list of
+    ExtensionParameter objects.
+
+    Leading LWSes must be trimmed.
+    """
+
+    state = http_header_util.ParsingState(data)
+
+    extension_list = []
+    while True:
+        extension = _parse_extension(state, allow_quoted_string)
+        if extension is not None:
+            extension_list.append(extension)
+
+        http_header_util.consume_lwses(state)
+
+        if http_header_util.peek(state) is None:
+            break
+
+        if not http_header_util.consume_string(state, ','):
+            raise ExtensionParsingException(
+                'Failed to parse Sec-WebSocket-Extensions header: '
+                'Expected a comma but found %r' %
+                http_header_util.peek(state))
+
+        http_header_util.consume_lwses(state)
+
+    if len(extension_list) == 0:
+        raise ExtensionParsingException(
+            'No valid extension entry found')
+
+    return extension_list
+
+
+def format_extension(extension):
+    """Formats an ExtensionParameter object."""
+
+    formatted_params = [extension.name()]
+    for param_name, param_value in extension.get_parameters():
+        if param_value is None:
+            formatted_params.append(param_name)
+        else:
+            quoted_value = http_header_util.quote_if_necessary(param_value)
+            formatted_params.append('%s=%s' % (param_name, quoted_value))
+    return '; '.join(formatted_params)
+
+
+def format_extensions(extension_list):
+    """Formats a list of ExtensionParameter objects."""
+
+    formatted_extension_list = []
+    for extension in extension_list:
+        formatted_extension_list.append(format_extension(extension))
+    return ', '.join(formatted_extension_list)
+
+
+# vi:sts=4 sw=4 et
diff --git a/module/lib/mod_pywebsocket/dispatch.py b/module/lib/mod_pywebsocket/dispatch.py
new file mode 100644
index 000000000..25905f180
--- /dev/null
+++ b/module/lib/mod_pywebsocket/dispatch.py
@@ -0,0 +1,387 @@
+# Copyright 2012, Google Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+"""Dispatch WebSocket request.
+"""
+
+
+import logging
+import os
+import re
+
+from mod_pywebsocket import common
+from mod_pywebsocket import handshake
+from mod_pywebsocket import msgutil
+from mod_pywebsocket import mux
+from mod_pywebsocket import stream
+from mod_pywebsocket import util
+
+
+_SOURCE_PATH_PATTERN = re.compile(r'(?i)_wsh\.py$')
+_SOURCE_SUFFIX = '_wsh.py'
+_DO_EXTRA_HANDSHAKE_HANDLER_NAME = 'web_socket_do_extra_handshake'
+_TRANSFER_DATA_HANDLER_NAME = 'web_socket_transfer_data'
+_PASSIVE_CLOSING_HANDSHAKE_HANDLER_NAME = (
+    'web_socket_passive_closing_handshake')
+
+
+class DispatchException(Exception):
+    """Exception in dispatching WebSocket request."""
+
+    def __init__(self, name, status=common.HTTP_STATUS_NOT_FOUND):
+        super(DispatchException, self).__init__(name)
+        self.status = status
+
+
+def _default_passive_closing_handshake_handler(request):
+    """Default web_socket_passive_closing_handshake handler."""
+
+    return common.STATUS_NORMAL_CLOSURE, ''
+
+
+def _normalize_path(path):
+    """Normalize path.
+
+    Args:
+        path: the path to normalize.
+
+    Path is converted to the absolute path.
+    The input path can use either '\\' or '/' as the separator.
+    The normalized path always uses '/' regardless of the platform.
+    """
+
+    path = path.replace('\\', os.path.sep)
+    path = os.path.realpath(path)
+    path = path.replace('\\', '/')
+    return path
+
+
+def _create_path_to_resource_converter(base_dir):
+    """Returns a function that converts the path of a WebSocket handler source
+    file to a resource string by removing the path to the base directory from
+    its head, removing _SOURCE_SUFFIX from its tail, and replacing path
+    separators in it with '/'.
+
+    Args:
+        base_dir: the path to the base directory.
+    """
+
+    base_dir = _normalize_path(base_dir)
+
+    base_len = len(base_dir)
+    suffix_len = len(_SOURCE_SUFFIX)
+
+    def converter(path):
+        if not path.endswith(_SOURCE_SUFFIX):
+            return None
+        # _normalize_path must not be used because resolving symlink breaks
+        # following path check.
+        path = path.replace('\\', '/')
+        if not path.startswith(base_dir):
+            return None
+        return path[base_len:-suffix_len]
+
+    return converter
+
+
+def _enumerate_handler_file_paths(directory):
+    """Returns a generator that enumerates WebSocket Handler source file names
+    in the given directory.
+    """
+
+    for root, unused_dirs, files in os.walk(directory):
+        for base in files:
+            path = os.path.join(root, base)
+            if _SOURCE_PATH_PATTERN.search(path):
+                yield path
+
+
+class _HandlerSuite(object):
+    """A handler suite holder class."""
+
+    def __init__(self, do_extra_handshake, transfer_data,
+                 passive_closing_handshake):
+        self.do_extra_handshake = do_extra_handshake
+        self.transfer_data = transfer_data
+        self.passive_closing_handshake = passive_closing_handshake
+
+
+def _source_handler_file(handler_definition):
+    """Source a handler definition string.
+
+    Args:
+        handler_definition: a string containing Python statements that define
+                            handler functions.
+    """
+
+    global_dic = {}
+    try:
+        exec handler_definition in global_dic
+    except Exception:
+        raise DispatchException('Error in sourcing handler:' +
+                                util.get_stack_trace())
+    passive_closing_handshake_handler = None
+    try:
+        passive_closing_handshake_handler = _extract_handler(
+            global_dic, _PASSIVE_CLOSING_HANDSHAKE_HANDLER_NAME)
+    except Exception:
+        passive_closing_handshake_handler = (
+            _default_passive_closing_handshake_handler)
+    return _HandlerSuite(
+        _extract_handler(global_dic, _DO_EXTRA_HANDSHAKE_HANDLER_NAME),
+        _extract_handler(global_dic, _TRANSFER_DATA_HANDLER_NAME),
+        passive_closing_handshake_handler)
+
+
+def _extract_handler(dic, name):
+    """Extracts a callable with the specified name from the given dictionary
+    dic.
+    """
+
+    if name not in dic:
+        raise DispatchException('%s is not defined.' % name)
+    handler = dic[name]
+    if not callable(handler):
+        raise DispatchException('%s is not callable.' % name)
+    return handler
+
+
+class Dispatcher(object):
+    """Dispatches WebSocket requests.
+
+    This class maintains a map from resource name to handlers.
+    """
+
+    def __init__(
+        self, root_dir, scan_dir=None,
+        allow_handlers_outside_root_dir=True):
+        """Construct an instance.
+
+        Args:
+            root_dir: The directory where handler definition files are
+                      placed.
+            scan_dir: The directory where handler definition files are
+                      searched. scan_dir must be a directory under root_dir,
+                      including root_dir itself.  If scan_dir is None,
+                      root_dir is used as scan_dir. scan_dir can be useful
+                      in saving scan time when root_dir contains many
+                      subdirectories.
+            allow_handlers_outside_root_dir: Scans handler files even if their
+                      canonical path is not under root_dir.
+        """
+
+        self._logger = util.get_class_logger(self)
+
+        self._handler_suite_map = {}
+        self._source_warnings = []
+        if scan_dir is None:
+            scan_dir = root_dir
+        if not os.path.realpath(scan_dir).startswith(
+                os.path.realpath(root_dir)):
+            raise DispatchException('scan_dir:%s must be a directory under '
+                                    'root_dir:%s.' % (scan_dir, root_dir))
+        self._source_handler_files_in_dir(
+            root_dir, scan_dir, allow_handlers_outside_root_dir)
+
+    def add_resource_path_alias(self,
+                                alias_resource_path, existing_resource_path):
+        """Add resource path alias.
+
+        Once added, request to alias_resource_path would be handled by
+        handler registered for existing_resource_path.
+
+        Args:
+            alias_resource_path: alias resource path
+            existing_resource_path: existing resource path
+        """
+        try:
+            handler_suite = self._handler_suite_map[existing_resource_path]
+            self._handler_suite_map[alias_resource_path] = handler_suite
+        except KeyError:
+            raise DispatchException('No handler for: %r' %
+                                    existing_resource_path)
+
+    def source_warnings(self):
+        """Return warnings in sourcing handlers."""
+
+        return self._source_warnings
+
+    def do_extra_handshake(self, request):
+        """Do extra checking in WebSocket handshake.
+
+        Select a handler based on request.uri and call its
+        web_socket_do_extra_handshake function.
+
+        Args:
+            request: mod_python request.
+
+        Raises:
+            DispatchException: when handler was not found
+            AbortedByUserException: when user handler abort connection
+            HandshakeException: when opening handshake failed
+        """
+
+        handler_suite = self.get_handler_suite(request.ws_resource)
+        if handler_suite is None:
+            raise DispatchException('No handler for: %r' % request.ws_resource)
+        do_extra_handshake_ = handler_suite.do_extra_handshake
+        try:
+            do_extra_handshake_(request)
+        except handshake.AbortedByUserException, e:
+            raise
+        except Exception, e:
+            util.prepend_message_to_exception(
+                    '%s raised exception for %s: ' % (
+                            _DO_EXTRA_HANDSHAKE_HANDLER_NAME,
+                            request.ws_resource),
+                    e)
+            raise handshake.HandshakeException(e, common.HTTP_STATUS_FORBIDDEN)
+
+    def transfer_data(self, request):
+        """Let a handler transfer_data with a WebSocket client.
+
+        Select a handler based on request.ws_resource and call its
+        web_socket_transfer_data function.
+
+        Args:
+            request: mod_python request.
+
+        Raises:
+            DispatchException: when handler was not found
+            AbortedByUserException: when user handler abort connection
+        """
+
+        # TODO(tyoshino): Terminate underlying TCP connection if possible.
+        try:
+            if mux.use_mux(request):
+                mux.start(request, self)
+            else:
+                handler_suite = self.get_handler_suite(request.ws_resource)
+                if handler_suite is None:
+                    raise DispatchException('No handler for: %r' %
+                                            request.ws_resource)
+                transfer_data_ = handler_suite.transfer_data
+                transfer_data_(request)
+
+            if not request.server_terminated:
+                request.ws_stream.close_connection()
+        # Catch non-critical exceptions the handler didn't handle.
+        except handshake.AbortedByUserException, e:
+            self._logger.debug('%s', e)
+            raise
+        except msgutil.BadOperationException, e:
+            self._logger.debug('%s', e)
+            request.ws_stream.close_connection(common.STATUS_ABNORMAL_CLOSURE)
+        except msgutil.InvalidFrameException, e:
+            # InvalidFrameException must be caught before
+            # ConnectionTerminatedException that catches InvalidFrameException.
+            self._logger.debug('%s', e)
+            request.ws_stream.close_connection(common.STATUS_PROTOCOL_ERROR)
+        except msgutil.UnsupportedFrameException, e:
+            self._logger.debug('%s', e)
+            request.ws_stream.close_connection(common.STATUS_UNSUPPORTED_DATA)
+        except stream.InvalidUTF8Exception, e:
+            self._logger.debug('%s', e)
+            request.ws_stream.close_connection(
+                common.STATUS_INVALID_FRAME_PAYLOAD_DATA)
+        except msgutil.ConnectionTerminatedException, e:
+            self._logger.debug('%s', e)
+        except Exception, e:
+            util.prepend_message_to_exception(
+                '%s raised exception for %s: ' % (
+                    _TRANSFER_DATA_HANDLER_NAME, request.ws_resource),
+                e)
+            raise
+
+    def passive_closing_handshake(self, request):
+        """Prepare code and reason for responding client initiated closing
+        handshake.
+        """
+
+        handler_suite = self.get_handler_suite(request.ws_resource)
+        if handler_suite is None:
+            return _default_passive_closing_handshake_handler(request)
+        return handler_suite.passive_closing_handshake(request)
+
+    def get_handler_suite(self, resource):
+        """Retrieves two handlers (one for extra handshake processing, and one
+        for data transfer) for the given request as a HandlerSuite object.
+        """
+
+        fragment = None
+        if '#' in resource:
+            resource, fragment = resource.split('#', 1)
+        if '?' in resource:
+            resource = resource.split('?', 1)[0]
+        handler_suite = self._handler_suite_map.get(resource)
+        if handler_suite and fragment:
+            raise DispatchException('Fragment identifiers MUST NOT be used on '
+                                    'WebSocket URIs',
+                                    common.HTTP_STATUS_BAD_REQUEST)
+        return handler_suite
+
+    def _source_handler_files_in_dir(
+        self, root_dir, scan_dir, allow_handlers_outside_root_dir):
+        """Source all the handler source files in the scan_dir directory.
+
+        The resource path is determined relative to root_dir.
+        """
+
+        # We build a map from resource to handler code assuming that there's
+        # only one path from root_dir to scan_dir and it can be obtained by
+        # comparing realpath of them.
+
+        # Here we cannot use abspath. See
+        # https://bugs.webkit.org/show_bug.cgi?id=31603
+
+        convert = _create_path_to_resource_converter(root_dir)
+        scan_realpath = os.path.realpath(scan_dir)
+        root_realpath = os.path.realpath(root_dir)
+        for path in _enumerate_handler_file_paths(scan_realpath):
+            if (not allow_handlers_outside_root_dir and
+                (not os.path.realpath(path).startswith(root_realpath))):
+                self._logger.debug(
+                    'Canonical path of %s is not under root directory' %
+                    path)
+                continue
+            try:
+                handler_suite = _source_handler_file(open(path).read())
+            except DispatchException, e:
+                self._source_warnings.append('%s: %s' % (path, e))
+                continue
+            resource = convert(path)
+            if resource is None:
+                self._logger.debug(
+                    'Path to resource conversion on %s failed' % path)
+            else:
+                self._handler_suite_map[convert(path)] = handler_suite
+
+
+# vi:sts=4 sw=4 et
diff --git a/module/lib/mod_pywebsocket/extensions.py b/module/lib/mod_pywebsocket/extensions.py
new file mode 100644
index 000000000..03dbf9ee1
--- /dev/null
+++ b/module/lib/mod_pywebsocket/extensions.py
@@ -0,0 +1,727 @@
+# Copyright 2012, Google Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+from mod_pywebsocket import common
+from mod_pywebsocket import util
+from mod_pywebsocket.http_header_util import quote_if_necessary
+
+
+_available_processors = {}
+
+
+class ExtensionProcessorInterface(object):
+
+    def name(self):
+        return None
+
+    def get_extension_response(self):
+        return None
+
+    def setup_stream_options(self, stream_options):
+        pass
+
+
+class DeflateStreamExtensionProcessor(ExtensionProcessorInterface):
+    """WebSocket DEFLATE stream extension processor.
+
+    Specification:
+    Section 9.2.1 in
+    http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-10
+    """
+
+    def __init__(self, request):
+        self._logger = util.get_class_logger(self)
+
+        self._request = request
+
+    def name(self):
+        return common.DEFLATE_STREAM_EXTENSION
+
+    def get_extension_response(self):
+        if len(self._request.get_parameter_names()) != 0:
+            return None
+
+        self._logger.debug(
+            'Enable %s extension', common.DEFLATE_STREAM_EXTENSION)
+
+        return common.ExtensionParameter(common.DEFLATE_STREAM_EXTENSION)
+
+    def setup_stream_options(self, stream_options):
+        stream_options.deflate_stream = True
+
+
+_available_processors[common.DEFLATE_STREAM_EXTENSION] = (
+    DeflateStreamExtensionProcessor)
+
+
+def _log_compression_ratio(logger, original_bytes, total_original_bytes,
+                           filtered_bytes, total_filtered_bytes):
+    # Print inf when ratio is not available.
+    ratio = float('inf')
+    average_ratio = float('inf')
+    if original_bytes != 0:
+        ratio = float(filtered_bytes) / original_bytes
+    if total_original_bytes != 0:
+        average_ratio = (
+            float(total_filtered_bytes) / total_original_bytes)
+    logger.debug('Outgoing compress ratio: %f (average: %f)' %
+        (ratio, average_ratio))
+
+
+def _log_decompression_ratio(logger, received_bytes, total_received_bytes,
+                             filtered_bytes, total_filtered_bytes):
+    # Print inf when ratio is not available.
+    ratio = float('inf')
+    average_ratio = float('inf')
+    if received_bytes != 0:
+        ratio = float(received_bytes) / filtered_bytes
+    if total_filtered_bytes != 0:
+        average_ratio = (
+            float(total_received_bytes) / total_filtered_bytes)
+    logger.debug('Incoming compress ratio: %f (average: %f)' %
+        (ratio, average_ratio))
+
+
+class DeflateFrameExtensionProcessor(ExtensionProcessorInterface):
+    """WebSocket Per-frame DEFLATE extension processor.
+
+    Specification:
+    http://tools.ietf.org/html/draft-tyoshino-hybi-websocket-perframe-deflate
+    """
+
+    _WINDOW_BITS_PARAM = 'max_window_bits'
+    _NO_CONTEXT_TAKEOVER_PARAM = 'no_context_takeover'
+
+    def __init__(self, request):
+        self._logger = util.get_class_logger(self)
+
+        self._request = request
+
+        self._response_window_bits = None
+        self._response_no_context_takeover = False
+        self._bfinal = False
+
+        # Counters for statistics.
+
+        # Total number of outgoing bytes supplied to this filter.
+        self._total_outgoing_payload_bytes = 0
+        # Total number of bytes sent to the network after applying this filter.
+        self._total_filtered_outgoing_payload_bytes = 0
+
+        # Total number of bytes received from the network.
+        self._total_incoming_payload_bytes = 0
+        # Total number of incoming bytes obtained after applying this filter.
+        self._total_filtered_incoming_payload_bytes = 0
+
+    def name(self):
+        return common.DEFLATE_FRAME_EXTENSION
+
+    def get_extension_response(self):
+        # Any unknown parameter will be just ignored.
+
+        window_bits = self._request.get_parameter_value(
+            self._WINDOW_BITS_PARAM)
+        no_context_takeover = self._request.has_parameter(
+            self._NO_CONTEXT_TAKEOVER_PARAM)
+        if (no_context_takeover and
+            self._request.get_parameter_value(
+                self._NO_CONTEXT_TAKEOVER_PARAM) is not None):
+            return None
+
+        if window_bits is not None:
+            try:
+                window_bits = int(window_bits)
+            except ValueError, e:
+                return None
+            if window_bits < 8 or window_bits > 15:
+                return None
+
+        self._deflater = util._RFC1979Deflater(
+            window_bits, no_context_takeover)
+
+        self._inflater = util._RFC1979Inflater()
+
+        self._compress_outgoing = True
+
+        response = common.ExtensionParameter(self._request.name())
+
+        if self._response_window_bits is not None:
+            response.add_parameter(
+                self._WINDOW_BITS_PARAM, str(self._response_window_bits))
+        if self._response_no_context_takeover:
+            response.add_parameter(
+                self._NO_CONTEXT_TAKEOVER_PARAM, None)
+
+        self._logger.debug(
+            'Enable %s extension ('
+            'request: window_bits=%s; no_context_takeover=%r, '
+            'response: window_wbits=%s; no_context_takeover=%r)' %
+            (self._request.name(),
+             window_bits,
+             no_context_takeover,
+             self._response_window_bits,
+             self._response_no_context_takeover))
+
+        return response
+
+    def setup_stream_options(self, stream_options):
+
+        class _OutgoingFilter(object):
+
+            def __init__(self, parent):
+                self._parent = parent
+
+            def filter(self, frame):
+                self._parent._outgoing_filter(frame)
+
+        class _IncomingFilter(object):
+
+            def __init__(self, parent):
+                self._parent = parent
+
+            def filter(self, frame):
+                self._parent._incoming_filter(frame)
+
+        stream_options.outgoing_frame_filters.append(
+            _OutgoingFilter(self))
+        stream_options.incoming_frame_filters.insert(
+            0, _IncomingFilter(self))
+
+    def set_response_window_bits(self, value):
+        self._response_window_bits = value
+
+    def set_response_no_context_takeover(self, value):
+        self._response_no_context_takeover = value
+
+    def set_bfinal(self, value):
+        self._bfinal = value
+
+    def enable_outgoing_compression(self):
+        self._compress_outgoing = True
+
+    def disable_outgoing_compression(self):
+        self._compress_outgoing = False
+
+    def _outgoing_filter(self, frame):
+        """Transform outgoing frames. This method is called only by
+        an _OutgoingFilter instance.
+        """
+
+        original_payload_size = len(frame.payload)
+        self._total_outgoing_payload_bytes += original_payload_size
+
+        if (not self._compress_outgoing or
+            common.is_control_opcode(frame.opcode)):
+            self._total_filtered_outgoing_payload_bytes += (
+                original_payload_size)
+            return
+
+        frame.payload = self._deflater.filter(
+            frame.payload, bfinal=self._bfinal)
+        frame.rsv1 = 1
+
+        filtered_payload_size = len(frame.payload)
+        self._total_filtered_outgoing_payload_bytes += filtered_payload_size
+
+        _log_compression_ratio(self._logger, original_payload_size,
+                               self._total_outgoing_payload_bytes,
+                               filtered_payload_size,
+                               self._total_filtered_outgoing_payload_bytes)
+
+    def _incoming_filter(self, frame):
+        """Transform incoming frames. This method is called only by
+        an _IncomingFilter instance.
+        """
+
+        received_payload_size = len(frame.payload)
+        self._total_incoming_payload_bytes += received_payload_size
+
+        if frame.rsv1 != 1 or common.is_control_opcode(frame.opcode):
+            self._total_filtered_incoming_payload_bytes += (
+                received_payload_size)
+            return
+
+        frame.payload = self._inflater.filter(frame.payload)
+        frame.rsv1 = 0
+
+        filtered_payload_size = len(frame.payload)
+        self._total_filtered_incoming_payload_bytes += filtered_payload_size
+
+        _log_decompression_ratio(self._logger, received_payload_size,
+                                 self._total_incoming_payload_bytes,
+                                 filtered_payload_size,
+                                 self._total_filtered_incoming_payload_bytes)
+
+
+_available_processors[common.DEFLATE_FRAME_EXTENSION] = (
+    DeflateFrameExtensionProcessor)
+
+
+# Adding vendor-prefixed deflate-frame extension.
+# TODO(bashi): Remove this after WebKit stops using vendor prefix.
+_available_processors[common.X_WEBKIT_DEFLATE_FRAME_EXTENSION] = (
+    DeflateFrameExtensionProcessor)
+
+
+def _parse_compression_method(data):
+    """Parses the value of "method" extension parameter."""
+
+    return common.parse_extensions(data, allow_quoted_string=True)
+
+
+def _create_accepted_method_desc(method_name, method_params):
+    """Creates accepted-method-desc from given method name and parameters"""
+
+    extension = common.ExtensionParameter(method_name)
+    for name, value in method_params:
+        extension.add_parameter(name, value)
+    return common.format_extension(extension)
+
+
+class CompressionExtensionProcessorBase(ExtensionProcessorInterface):
+    """Base class for Per-frame and Per-message compression extension."""
+
+    _METHOD_PARAM = 'method'
+
+    def __init__(self, request):
+        self._logger = util.get_class_logger(self)
+        self._request = request
+        self._compression_method_name = None
+        self._compression_processor = None
+        self._compression_processor_hook = None
+
+    def name(self):
+        return ''
+
+    def _lookup_compression_processor(self, method_desc):
+        return None
+
+    def _get_compression_processor_response(self):
+        """Looks up the compression processor based on the self._request and
+           returns the compression processor's response.
+        """
+
+        method_list = self._request.get_parameter_value(self._METHOD_PARAM)
+        if method_list is None:
+            return None
+        methods = _parse_compression_method(method_list)
+        if methods is None:
+            return None
+        comression_processor = None
+        # The current implementation tries only the first method that matches
+        # supported algorithm. Following methods aren't tried even if the
+        # first one is rejected.
+        # TODO(bashi): Need to clarify this behavior.
+        for method_desc in methods:
+            compression_processor = self._lookup_compression_processor(
+                method_desc)
+            if compression_processor is not None:
+                self._compression_method_name = method_desc.name()
+                break
+        if compression_processor is None:
+            return None
+
+        if self._compression_processor_hook:
+            self._compression_processor_hook(compression_processor)
+
+        processor_response = compression_processor.get_extension_response()
+        if processor_response is None:
+            return None
+        self._compression_processor = compression_processor
+        return processor_response
+
+    def get_extension_response(self):
+        processor_response = self._get_compression_processor_response()
+        if processor_response is None:
+            return None
+
+        response = common.ExtensionParameter(self._request.name())
+        accepted_method_desc = _create_accepted_method_desc(
+                                   self._compression_method_name,
+                                   processor_response.get_parameters())
+        response.add_parameter(self._METHOD_PARAM, accepted_method_desc)
+        self._logger.debug(
+            'Enable %s extension (method: %s)' %
+            (self._request.name(), self._compression_method_name))
+        return response
+
+    def setup_stream_options(self, stream_options):
+        if self._compression_processor is None:
+            return
+        self._compression_processor.setup_stream_options(stream_options)
+
+    def set_compression_processor_hook(self, hook):
+        self._compression_processor_hook = hook
+
+    def get_compression_processor(self):
+        return self._compression_processor
+
+
+class PerFrameCompressionExtensionProcessor(CompressionExtensionProcessorBase):
+    """WebSocket Per-frame compression extension processor.
+
+    Specification:
+    http://tools.ietf.org/html/draft-ietf-hybi-websocket-perframe-compression
+    """
+
+    _DEFLATE_METHOD = 'deflate'
+
+    def __init__(self, request):
+        CompressionExtensionProcessorBase.__init__(self, request)
+
+    def name(self):
+        return common.PERFRAME_COMPRESSION_EXTENSION
+
+    def _lookup_compression_processor(self, method_desc):
+        if method_desc.name() == self._DEFLATE_METHOD:
+            return DeflateFrameExtensionProcessor(method_desc)
+        return None
+
+
+_available_processors[common.PERFRAME_COMPRESSION_EXTENSION] = (
+    PerFrameCompressionExtensionProcessor)
+
+
+class DeflateMessageProcessor(ExtensionProcessorInterface):
+    """Per-message deflate processor."""
+
+    _S2C_MAX_WINDOW_BITS_PARAM = 's2c_max_window_bits'
+    _S2C_NO_CONTEXT_TAKEOVER_PARAM = 's2c_no_context_takeover'
+    _C2S_MAX_WINDOW_BITS_PARAM = 'c2s_max_window_bits'
+    _C2S_NO_CONTEXT_TAKEOVER_PARAM = 'c2s_no_context_takeover'
+
+    def __init__(self, request):
+        self._request = request
+        self._logger = util.get_class_logger(self)
+
+        self._c2s_max_window_bits = None
+        self._c2s_no_context_takeover = False
+        self._bfinal = False
+
+        self._compress_outgoing_enabled = False
+
+        # True if a message is fragmented and compression is ongoing.
+        self._compress_ongoing = False
+
+        # Counters for statistics.
+
+        # Total number of outgoing bytes supplied to this filter.
+        self._total_outgoing_payload_bytes = 0
+        # Total number of bytes sent to the network after applying this filter.
+        self._total_filtered_outgoing_payload_bytes = 0
+
+        # Total number of bytes received from the network.
+        self._total_incoming_payload_bytes = 0
+        # Total number of incoming bytes obtained after applying this filter.
+        self._total_filtered_incoming_payload_bytes = 0
+
+    def name(self):
+        return 'deflate'
+
+    def get_extension_response(self):
+        # Any unknown parameter will be just ignored.
+
+        s2c_max_window_bits = self._request.get_parameter_value(
+            self._S2C_MAX_WINDOW_BITS_PARAM)
+        if s2c_max_window_bits is not None:
+            try:
+                s2c_max_window_bits = int(s2c_max_window_bits)
+            except ValueError, e:
+                return None
+            if s2c_max_window_bits < 8 or s2c_max_window_bits > 15:
+                return None
+
+        s2c_no_context_takeover = self._request.has_parameter(
+            self._S2C_NO_CONTEXT_TAKEOVER_PARAM)
+        if (s2c_no_context_takeover and
+            self._request.get_parameter_value(
+                self._S2C_NO_CONTEXT_TAKEOVER_PARAM) is not None):
+            return None
+
+        self._deflater = util._RFC1979Deflater(
+            s2c_max_window_bits, s2c_no_context_takeover)
+
+        self._inflater = util._RFC1979Inflater()
+
+        self._compress_outgoing_enabled = True
+
+        response = common.ExtensionParameter(self._request.name())
+
+        if s2c_max_window_bits is not None:
+            response.add_parameter(
+                self._S2C_MAX_WINDOW_BITS_PARAM, str(s2c_max_window_bits))
+
+        if s2c_no_context_takeover:
+            response.add_parameter(
+                self._S2C_NO_CONTEXT_TAKEOVER_PARAM, None)
+
+        if self._c2s_max_window_bits is not None:
+            response.add_parameter(
+                self._C2S_MAX_WINDOW_BITS_PARAM,
+                str(self._c2s_max_window_bits))
+        if self._c2s_no_context_takeover:
+            response.add_parameter(
+                self._C2S_NO_CONTEXT_TAKEOVER_PARAM, None)
+
+        self._logger.debug(
+            'Enable %s extension ('
+            'request: s2c_max_window_bits=%s; s2c_no_context_takeover=%r, '
+            'response: c2s_max_window_bits=%s; c2s_no_context_takeover=%r)' %
+            (self._request.name(),
+             s2c_max_window_bits,
+             s2c_no_context_takeover,
+             self._c2s_max_window_bits,
+             self._c2s_no_context_takeover))
+
+        return response
+
+    def setup_stream_options(self, stream_options):
+        class _OutgoingMessageFilter(object):
+
+            def __init__(self, parent):
+                self._parent = parent
+
+            def filter(self, message, end=True, binary=False):
+                return self._parent._process_outgoing_message(
+                    message, end, binary)
+
+        class _IncomingMessageFilter(object):
+
+            def __init__(self, parent):
+                self._parent = parent
+                self._decompress_next_message = False
+
+            def decompress_next_message(self):
+                self._decompress_next_message = True
+
+            def filter(self, message):
+                message = self._parent._process_incoming_message(
+                    message, self._decompress_next_message)
+                self._decompress_next_message = False
+                return message
+
+        self._outgoing_message_filter = _OutgoingMessageFilter(self)
+        self._incoming_message_filter = _IncomingMessageFilter(self)
+        stream_options.outgoing_message_filters.append(
+            self._outgoing_message_filter)
+        stream_options.incoming_message_filters.append(
+            self._incoming_message_filter)
+
+        class _OutgoingFrameFilter(object):
+
+            def __init__(self, parent):
+                self._parent = parent
+                self._set_compression_bit = False
+
+            def set_compression_bit(self):
+                self._set_compression_bit = True
+
+            def filter(self, frame):
+                self._parent._process_outgoing_frame(
+                    frame, self._set_compression_bit)
+                self._set_compression_bit = False
+
+        class _IncomingFrameFilter(object):
+
+            def __init__(self, parent):
+                self._parent = parent
+
+            def filter(self, frame):
+                self._parent._process_incoming_frame(frame)
+
+        self._outgoing_frame_filter = _OutgoingFrameFilter(self)
+        self._incoming_frame_filter = _IncomingFrameFilter(self)
+        stream_options.outgoing_frame_filters.append(
+            self._outgoing_frame_filter)
+        stream_options.incoming_frame_filters.append(
+            self._incoming_frame_filter)
+
+        stream_options.encode_text_message_to_utf8 = False
+
+    def set_c2s_max_window_bits(self, value):
+        self._c2s_max_window_bits = value
+
+    def set_c2s_no_context_takeover(self, value):
+        self._c2s_no_context_takeover = value
+
+    def set_bfinal(self, value):
+        self._bfinal = value
+
+    def enable_outgoing_compression(self):
+        self._compress_outgoing_enabled = True
+
+    def disable_outgoing_compression(self):
+        self._compress_outgoing_enabled = False
+
+    def _process_incoming_message(self, message, decompress):
+        if not decompress:
+            return message
+
+        received_payload_size = len(message)
+        self._total_incoming_payload_bytes += received_payload_size
+
+        message = self._inflater.filter(message)
+
+        filtered_payload_size = len(message)
+        self._total_filtered_incoming_payload_bytes += filtered_payload_size
+
+        _log_decompression_ratio(self._logger, received_payload_size,
+                                 self._total_incoming_payload_bytes,
+                                 filtered_payload_size,
+                                 self._total_filtered_incoming_payload_bytes)
+
+        return message
+
+    def _process_outgoing_message(self, message, end, binary):
+        if not binary:
+            message = message.encode('utf-8')
+
+        if not self._compress_outgoing_enabled:
+            return message
+
+        original_payload_size = len(message)
+        self._total_outgoing_payload_bytes += original_payload_size
+
+        message = self._deflater.filter(
+            message, flush=end, bfinal=self._bfinal)
+
+        filtered_payload_size = len(message)
+        self._total_filtered_outgoing_payload_bytes += filtered_payload_size
+
+        _log_compression_ratio(self._logger, original_payload_size,
+                               self._total_outgoing_payload_bytes,
+                               filtered_payload_size,
+                               self._total_filtered_outgoing_payload_bytes)
+
+        if not self._compress_ongoing:
+            self._outgoing_frame_filter.set_compression_bit()
+        self._compress_ongoing = not end
+        return message
+
+    def _process_incoming_frame(self, frame):
+        if frame.rsv1 == 1 and not common.is_control_opcode(frame.opcode):
+            self._incoming_message_filter.decompress_next_message()
+            frame.rsv1 = 0
+
+    def _process_outgoing_frame(self, frame, compression_bit):
+        if (not compression_bit or
+            common.is_control_opcode(frame.opcode)):
+            return
+
+        frame.rsv1 = 1
+
+
+class PerMessageCompressionExtensionProcessor(
+    CompressionExtensionProcessorBase):
+    """WebSocket Per-message compression extension processor.
+
+    Specification:
+    http://tools.ietf.org/html/draft-ietf-hybi-permessage-compression
+    """
+
+    _DEFLATE_METHOD = 'deflate'
+
+    def __init__(self, request):
+        CompressionExtensionProcessorBase.__init__(self, request)
+
+    def name(self):
+        return common.PERMESSAGE_COMPRESSION_EXTENSION
+
+    def _lookup_compression_processor(self, method_desc):
+        if method_desc.name() == self._DEFLATE_METHOD:
+            return DeflateMessageProcessor(method_desc)
+        return None
+
+
+_available_processors[common.PERMESSAGE_COMPRESSION_EXTENSION] = (
+    PerMessageCompressionExtensionProcessor)
+
+
+# Adding vendor-prefixed permessage-compress extension.
+# TODO(bashi): Remove this after WebKit stops using vendor prefix.
+_available_processors[common.X_WEBKIT_PERMESSAGE_COMPRESSION_EXTENSION] = (
+    PerMessageCompressionExtensionProcessor)
+
+
+class MuxExtensionProcessor(ExtensionProcessorInterface):
+    """WebSocket multiplexing extension processor."""
+
+    _QUOTA_PARAM = 'quota'
+
+    def __init__(self, request):
+        self._request = request
+
+    def name(self):
+        return common.MUX_EXTENSION
+
+    def get_extension_response(self, ws_request,
+                               logical_channel_extensions):
+        # Mux extension cannot be used after extensions that depend on
+        # frame boundary, extension data field, or any reserved bits
+        # which are attributed to each frame.
+        for extension in logical_channel_extensions:
+            name = extension.name()
+            if (name == common.PERFRAME_COMPRESSION_EXTENSION or
+                name == common.DEFLATE_FRAME_EXTENSION or
+                name == common.X_WEBKIT_DEFLATE_FRAME_EXTENSION):
+                return None
+
+        quota = self._request.get_parameter_value(self._QUOTA_PARAM)
+        if quota is None:
+            ws_request.mux_quota = 0
+        else:
+            try:
+                quota = int(quota)
+            except ValueError, e:
+                return None
+            if quota < 0 or quota >= 2 ** 32:
+                return None
+            ws_request.mux_quota = quota
+
+        ws_request.mux = True
+        ws_request.mux_extensions = logical_channel_extensions
+        return common.ExtensionParameter(common.MUX_EXTENSION)
+
+    def setup_stream_options(self, stream_options):
+        pass
+
+
+_available_processors[common.MUX_EXTENSION] = MuxExtensionProcessor
+
+
+def get_extension_processor(extension_request):
+    global _available_processors
+    processor_class = _available_processors.get(extension_request.name())
+    if processor_class is None:
+        return None
+    return processor_class(extension_request)
+
+
+# vi:sts=4 sw=4 et
diff --git a/module/lib/mod_pywebsocket/handshake/__init__.py b/module/lib/mod_pywebsocket/handshake/__init__.py
new file mode 100644
index 000000000..194f6b395
--- /dev/null
+++ b/module/lib/mod_pywebsocket/handshake/__init__.py
@@ -0,0 +1,110 @@
+# Copyright 2011, Google Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+"""WebSocket opening handshake processor. This class try to apply available
+opening handshake processors for each protocol version until a connection is
+successfully established.
+"""
+
+
+import logging
+
+from mod_pywebsocket import common
+from mod_pywebsocket.handshake import hybi00
+from mod_pywebsocket.handshake import hybi
+# Export AbortedByUserException, HandshakeException, and VersionException
+# symbol from this module.
+from mod_pywebsocket.handshake._base import AbortedByUserException
+from mod_pywebsocket.handshake._base import HandshakeException
+from mod_pywebsocket.handshake._base import VersionException
+
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def do_handshake(request, dispatcher, allowDraft75=False, strict=False):
+    """Performs WebSocket handshake.
+
+    Args:
+        request: mod_python request.
+        dispatcher: Dispatcher (dispatch.Dispatcher).
+        allowDraft75: obsolete argument. ignored.
+        strict: obsolete argument. ignored.
+
+    Handshaker will add attributes such as ws_resource in performing
+    handshake.
+    """
+
+    _LOGGER.debug('Client\'s opening handshake resource: %r', request.uri)
+    # To print mimetools.Message as escaped one-line string, we converts
+    # headers_in to dict object. Without conversion, if we use %r, it just
+    # prints the type and address, and if we use %s, it prints the original
+    # header string as multiple lines.
+    #
+    # Both mimetools.Message and MpTable_Type of mod_python can be
+    # converted to dict.
+    #
+    # mimetools.Message.__str__ returns the original header string.
+    # dict(mimetools.Message object) returns the map from header names to
+    # header values. While MpTable_Type doesn't have such __str__ but just
+    # __repr__ which formats itself as well as dictionary object.
+    _LOGGER.debug(
+        'Client\'s opening handshake headers: %r', dict(request.headers_in))
+
+    handshakers = []
+    handshakers.append(
+        ('RFC 6455', hybi.Handshaker(request, dispatcher)))
+    handshakers.append(
+        ('HyBi 00', hybi00.Handshaker(request, dispatcher)))
+
+    for name, handshaker in handshakers:
+        _LOGGER.debug('Trying protocol version %s', name)
+        try:
+            handshaker.do_handshake()
+            _LOGGER.info('Established (%s protocol)', name)
+            return
+        except HandshakeException, e:
+            _LOGGER.debug(
+                'Failed to complete opening handshake as %s protocol: %r',
+                name, e)
+            if e.status:
+                raise e
+        except AbortedByUserException, e:
+            raise
+        except VersionException, e:
+            raise
+
+    # TODO(toyoshim): Add a test to cover the case all handshakers fail.
+    raise HandshakeException(
+        'Failed to complete opening handshake for all available protocols',
+        status=common.HTTP_STATUS_BAD_REQUEST)
+
+
+# vi:sts=4 sw=4 et
diff --git a/module/lib/mod_pywebsocket/handshake/_base.py b/module/lib/mod_pywebsocket/handshake/_base.py
new file mode 100644
index 000000000..e5c94ca90
--- /dev/null
+++ b/module/lib/mod_pywebsocket/handshake/_base.py
@@ -0,0 +1,226 @@
+# Copyright 2012, Google Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+"""Common functions and exceptions used by WebSocket opening handshake
+processors.
+"""
+
+
+from mod_pywebsocket import common
+from mod_pywebsocket import http_header_util
+
+
+class AbortedByUserException(Exception):
+    """Exception for aborting a connection intentionally.
+
+    If this exception is raised in do_extra_handshake handler, the connection
+    will be abandoned. No other WebSocket or HTTP(S) handler will be invoked.
+
+    If this exception is raised in transfer_data_handler, the connection will
+    be closed without closing handshake. No other WebSocket or HTTP(S) handler
+    will be invoked.
+    """
+
+    pass
+
+
+class HandshakeException(Exception):
+    """This exception will be raised when an error occurred while processing
+    WebSocket initial handshake.
+    """
+
+    def __init__(self, name, status=None):
+        super(HandshakeException, self).__init__(name)
+        self.status = status
+
+
+class VersionException(Exception):
+    """This exception will be raised when a version of client request does not
+    match with version the server supports.
+    """
+
+    def __init__(self, name, supported_versions=''):
+        """Construct an instance.
+
+        Args:
+            supported_version: a str object to show supported hybi versions.
+                               (e.g. '8, 13')
+        """
+        super(VersionException, self).__init__(name)
+        self.supported_versions = supported_versions
+
+
+def get_default_port(is_secure):
+    if is_secure:
+        return common.DEFAULT_WEB_SOCKET_SECURE_PORT
+    else:
+        return common.DEFAULT_WEB_SOCKET_PORT
+
+
+def validate_subprotocol(subprotocol, hixie):
+    """Validate a value in the Sec-WebSocket-Protocol field.
+
+    See
+    - RFC 6455: Section 4.1., 4.2.2., and 4.3.
+    - HyBi 00: Section 4.1. Opening handshake
+
+    Args:
+         hixie: if True, checks if characters in subprotocol are in range
+                between U+0020 and U+007E. It's required by HyBi 00 but not by
+                RFC 6455.
+    """
+
+    if not subprotocol:
+        raise HandshakeException('Invalid subprotocol name: empty')
+    if hixie:
+        # Parameter should be in the range U+0020 to U+007E.
+        for c in subprotocol:
+            if not 0x20 <= ord(c) <= 0x7e:
+                raise HandshakeException(
+                    'Illegal character in subprotocol name: %r' % c)
+    else:
+        # Parameter should be encoded HTTP token.
+        state = http_header_util.ParsingState(subprotocol)
+        token = http_header_util.consume_token(state)
+        rest = http_header_util.peek(state)
+        # If |rest| is not None, |subprotocol| is not one token or invalid. If
+        # |rest| is None, |token| must not be None because |subprotocol| is
+        # concatenation of |token| and |rest| and is not None.
+        if rest is not None:
+            raise HandshakeException('Invalid non-token string in subprotocol '
+                                     'name: %r' % rest)
+
+
+def parse_host_header(request):
+    fields = request.headers_in['Host'].split(':', 1)
+    if len(fields) == 1:
+        return fields[0], get_default_port(request.is_https())
+    try:
+        return fields[0], int(fields[1])
+    except ValueError, e:
+        raise HandshakeException('Invalid port number format: %r' % e)
+
+
+def format_header(name, value):
+    return '%s: %s\r\n' % (name, value)
+
+
+def build_location(request):
+    """Build WebSocket location for request."""
+    location_parts = []
+    if request.is_https():
+        location_parts.append(common.WEB_SOCKET_SECURE_SCHEME)
+    else:
+        location_parts.append(common.WEB_SOCKET_SCHEME)
+    location_parts.append('://')
+    host, port = parse_host_header(request)
+    connection_port = request.connection.local_addr[1]
+    if port != connection_port:
+        raise HandshakeException('Header/connection port mismatch: %d/%d' %
+                                 (port, connection_port))
+    location_parts.append(host)
+    if (port != get_default_port(request.is_https())):
+        location_parts.append(':')
+        location_parts.append(str(port))
+    location_parts.append(request.uri)
+    return ''.join(location_parts)
+
+
+def get_mandatory_header(request, key):
+    value = request.headers_in.get(key)
+    if value is None:
+        raise HandshakeException('Header %s is not defined' % key)
+    return value
+
+
+def validate_mandatory_header(request, key, expected_value, fail_status=None):
+    value = get_mandatory_header(request, key)
+
+    if value.lower() != expected_value.lower():
+        raise HandshakeException(
+            'Expected %r for header %s but found %r (case-insensitive)' %
+            (expected_value, key, value), status=fail_status)
+
+
+def check_request_line(request):
+    # 5.1 1. The three character UTF-8 string "GET".
+    # 5.1 2. A UTF-8-encoded U+0020 SPACE character (0x20 byte).
+    if request.method != 'GET':
+        raise HandshakeException('Method is not GET: %r' % request.method)
+
+    if request.protocol != 'HTTP/1.1':
+        raise HandshakeException('Version is not HTTP/1.1: %r' %
+                                 request.protocol)
+
+
+def check_header_lines(request, mandatory_headers):
+    check_request_line(request)
+
+    # The expected field names, and the meaning of their corresponding
+    # values, are as follows.
+    #  |Upgrade| and |Connection|
+    for key, expected_value in mandatory_headers:
+        validate_mandatory_header(request, key, expected_value)
+
+
+def parse_token_list(data):
+    """Parses a header value which follows 1#token and returns parsed elements
+    as a list of strings.
+
+    Leading LWSes must be trimmed.
+    """
+
+    state = http_header_util.ParsingState(data)
+
+    token_list = []
+
+    while True:
+        token = http_header_util.consume_token(state)
+        if token is not None:
+            token_list.append(token)
+
+        http_header_util.consume_lwses(state)
+
+        if http_header_util.peek(state) is None:
+            break
+
+        if not http_header_util.consume_string(state, ','):
+            raise HandshakeException(
+                'Expected a comma but found %r' % http_header_util.peek(state))
+
+        http_header_util.consume_lwses(state)
+
+    if len(token_list) == 0:
+        raise HandshakeException('No valid token found')
+
+    return token_list
+
+
+# vi:sts=4 sw=4 et
diff --git a/module/lib/mod_pywebsocket/handshake/hybi.py b/module/lib/mod_pywebsocket/handshake/hybi.py
new file mode 100644
index 000000000..fc0e2a096
--- /dev/null
+++ b/module/lib/mod_pywebsocket/handshake/hybi.py
@@ -0,0 +1,404 @@
+# Copyright 2012, Google Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+"""This file provides the opening handshake processor for the WebSocket
+protocol (RFC 6455).
+
+Specification:
+http://tools.ietf.org/html/rfc6455
+"""
+
+
+# Note: request.connection.write is used in this module, even though mod_python
+# document says that it should be used only in connection handlers.
+# Unfortunately, we have no other options. For example, request.write is not
+# suitable because it doesn't allow direct raw bytes writing.
+
+
+import base64
+import logging
+import os
+import re
+
+from mod_pywebsocket import common
+from mod_pywebsocket.extensions import get_extension_processor
+from mod_pywebsocket.handshake._base import check_request_line
+from mod_pywebsocket.handshake._base import format_header
+from mod_pywebsocket.handshake._base import get_mandatory_header
+from mod_pywebsocket.handshake._base import HandshakeException
+from mod_pywebsocket.handshake._base import parse_token_list
+from mod_pywebsocket.handshake._base import validate_mandatory_header
+from mod_pywebsocket.handshake._base import validate_subprotocol
+from mod_pywebsocket.handshake._base import VersionException
+from mod_pywebsocket.stream import Stream
+from mod_pywebsocket.stream import StreamOptions
+from mod_pywebsocket import util
+
+
+# Used to validate the value in the Sec-WebSocket-Key header strictly. RFC 4648
+# disallows non-zero padding, so the character right before == must be any of
+# A, Q, g and w.
+_SEC_WEBSOCKET_KEY_REGEX = re.compile('^[+/0-9A-Za-z]{21}[AQgw]==$')
+
+# Defining aliases for values used frequently.
+_VERSION_HYBI08 = common.VERSION_HYBI08
+_VERSION_HYBI08_STRING = str(_VERSION_HYBI08)
+_VERSION_LATEST = common.VERSION_HYBI_LATEST
+_VERSION_LATEST_STRING = str(_VERSION_LATEST)
+_SUPPORTED_VERSIONS = [
+    _VERSION_LATEST,
+    _VERSION_HYBI08,
+]
+
+
+def compute_accept(key):
+    """Computes value for the Sec-WebSocket-Accept header from value of the
+    Sec-WebSocket-Key header.
+    """
+
+    accept_binary = util.sha1_hash(
+        key + common.WEBSOCKET_ACCEPT_UUID).digest()
+    accept = base64.b64encode(accept_binary)
+
+    return (accept, accept_binary)
+
+
+class Handshaker(object):
+    """Opening handshake processor for the WebSocket protocol (RFC 6455)."""
+
+    def __init__(self, request, dispatcher):
+        """Construct an instance.
+
+        Args:
+            request: mod_python request.
+            dispatcher: Dispatcher (dispatch.Dispatcher).
+
+        Handshaker will add attributes such as ws_resource during handshake.
+        """
+
+        self._logger = util.get_class_logger(self)
+
+        self._request = request
+        self._dispatcher = dispatcher
+
+    def _validate_connection_header(self):
+        connection = get_mandatory_header(
+            self._request, common.CONNECTION_HEADER)
+
+        try:
+            connection_tokens = parse_token_list(connection)
+        except HandshakeException, e:
+            raise HandshakeException(
+                'Failed to parse %s: %s' % (common.CONNECTION_HEADER, e))
+
+        connection_is_valid = False
+        for token in connection_tokens:
+            if token.lower() == common.UPGRADE_CONNECTION_TYPE.lower():
+                connection_is_valid = True
+                break
+        if not connection_is_valid:
+            raise HandshakeException(
+                '%s header doesn\'t contain "%s"' %
+                (common.CONNECTION_HEADER, common.UPGRADE_CONNECTION_TYPE))
+
+    def do_handshake(self):
+        self._request.ws_close_code = None
+        self._request.ws_close_reason = None
+
+        # Parsing.
+
+        check_request_line(self._request)
+
+        validate_mandatory_header(
+            self._request,
+            common.UPGRADE_HEADER,
+            common.WEBSOCKET_UPGRADE_TYPE)
+
+        self._validate_connection_header()
+
+        self._request.ws_resource = self._request.uri
+
+        unused_host = get_mandatory_header(self._request, common.HOST_HEADER)
+
+        self._request.ws_version = self._check_version()
+
+        # This handshake must be based on latest hybi. We are responsible to
+        # fallback to HTTP on handshake failure as latest hybi handshake
+        # specifies.
+        try:
+            self._get_origin()
+            self._set_protocol()
+            self._parse_extensions()
+
+            # Key validation, response generation.
+
+            key = self._get_key()
+            (accept, accept_binary) = compute_accept(key)
+            self._logger.debug(
+                '%s: %r (%s)',
+                common.SEC_WEBSOCKET_ACCEPT_HEADER,
+                accept,
+                util.hexify(accept_binary))
+
+            self._logger.debug('Protocol version is RFC 6455')
+
+            # Setup extension processors.
+
+            processors = []
+            if self._request.ws_requested_extensions is not None:
+                for extension_request in self._request.ws_requested_extensions:
+                    processor = get_extension_processor(extension_request)
+                    # Unknown extension requests are just ignored.
+                    if processor is not None:
+                        processors.append(processor)
+            self._request.ws_extension_processors = processors
+
+            # Extra handshake handler may modify/remove processors.
+            self._dispatcher.do_extra_handshake(self._request)
+            processors = filter(lambda processor: processor is not None,
+                                self._request.ws_extension_processors)
+
+            accepted_extensions = []
+
+            # We need to take care of mux extension here. Extensions that
+            # are placed before mux should be applied to logical channels.
+            mux_index = -1
+            for i, processor in enumerate(processors):
+                if processor.name() == common.MUX_EXTENSION:
+                    mux_index = i
+                    break
+            if mux_index >= 0:
+                mux_processor = processors[mux_index]
+                logical_channel_processors = processors[:mux_index]
+                processors = processors[mux_index+1:]
+
+                for processor in logical_channel_processors:
+                    extension_response = processor.get_extension_response()
+                    if extension_response is None:
+                        # Rejected.
+                        continue
+                    accepted_extensions.append(extension_response)
+                # Pass a shallow copy of accepted_extensions as extensions for
+                # logical channels.
+                mux_response = mux_processor.get_extension_response(
+                    self._request, accepted_extensions[:])
+                if mux_response is not None:
+                    accepted_extensions.append(mux_response)
+
+            stream_options = StreamOptions()
+
+            # When there is mux extension, here, |processors| contain only
+            # prosessors for extensions placed after mux.
+            for processor in processors:
+
+                extension_response = processor.get_extension_response()
+                if extension_response is None:
+                    # Rejected.
+                    continue
+
+                accepted_extensions.append(extension_response)
+
+                processor.setup_stream_options(stream_options)
+
+            if len(accepted_extensions) > 0:
+                self._request.ws_extensions = accepted_extensions
+                self._logger.debug(
+                    'Extensions accepted: %r',
+                    map(common.ExtensionParameter.name, accepted_extensions))
+            else:
+                self._request.ws_extensions = None
+
+            self._request.ws_stream = self._create_stream(stream_options)
+
+            if self._request.ws_requested_protocols is not None:
+                if self._request.ws_protocol is None:
+                    raise HandshakeException(
+                        'do_extra_handshake must choose one subprotocol from '
+                        'ws_requested_protocols and set it to ws_protocol')
+                validate_subprotocol(self._request.ws_protocol, hixie=False)
+
+                self._logger.debug(
+                    'Subprotocol accepted: %r',
+                    self._request.ws_protocol)
+            else:
+                if self._request.ws_protocol is not None:
+                    raise HandshakeException(
+                        'ws_protocol must be None when the client didn\'t '
+                        'request any subprotocol')
+
+            self._send_handshake(accept)
+        except HandshakeException, e:
+            if not e.status:
+                # Fallback to 400 bad request by default.
+                e.status = common.HTTP_STATUS_BAD_REQUEST
+            raise e
+
+    def _get_origin(self):
+        if self._request.ws_version is _VERSION_HYBI08:
+            origin_header = common.SEC_WEBSOCKET_ORIGIN_HEADER
+        else:
+            origin_header = common.ORIGIN_HEADER
+        origin = self._request.headers_in.get(origin_header)
+        if origin is None:
+            self._logger.debug('Client request does not have origin header')
+        self._request.ws_origin = origin
+
+    def _check_version(self):
+        version = get_mandatory_header(self._request,
+                                       common.SEC_WEBSOCKET_VERSION_HEADER)
+        if version == _VERSION_HYBI08_STRING:
+            return _VERSION_HYBI08
+        if version == _VERSION_LATEST_STRING:
+            return _VERSION_LATEST
+
+        if version.find(',') >= 0:
+            raise HandshakeException(
+                'Multiple versions (%r) are not allowed for header %s' %
+                (version, common.SEC_WEBSOCKET_VERSION_HEADER),
+                status=common.HTTP_STATUS_BAD_REQUEST)
+        raise VersionException(
+            'Unsupported version %r for header %s' %
+            (version, common.SEC_WEBSOCKET_VERSION_HEADER),
+            supported_versions=', '.join(map(str, _SUPPORTED_VERSIONS)))
+
+    def _set_protocol(self):
+        self._request.ws_protocol = None
+
+        protocol_header = self._request.headers_in.get(
+            common.SEC_WEBSOCKET_PROTOCOL_HEADER)
+
+        if protocol_header is None:
+            self._request.ws_requested_protocols = None
+            return
+
+        self._request.ws_requested_protocols = parse_token_list(
+            protocol_header)
+        self._logger.debug('Subprotocols requested: %r',
+                           self._request.ws_requested_protocols)
+
+    def _parse_extensions(self):
+        extensions_header = self._request.headers_in.get(
+            common.SEC_WEBSOCKET_EXTENSIONS_HEADER)
+        if not extensions_header:
+            self._request.ws_requested_extensions = None
+            return
+
+        if self._request.ws_version is common.VERSION_HYBI08:
+            allow_quoted_string=False
+        else:
+            allow_quoted_string=True
+        try:
+            self._request.ws_requested_extensions = common.parse_extensions(
+                extensions_header, allow_quoted_string=allow_quoted_string)
+        except common.ExtensionParsingException, e:
+            raise HandshakeException(
+                'Failed to parse Sec-WebSocket-Extensions header: %r' % e)
+
+        self._logger.debug(
+            'Extensions requested: %r',
+            map(common.ExtensionParameter.name,
+                self._request.ws_requested_extensions))
+
+    def _validate_key(self, key):
+        if key.find(',') >= 0:
+            raise HandshakeException('Request has multiple %s header lines or '
+                                     'contains illegal character \',\': %r' %
+                                     (common.SEC_WEBSOCKET_KEY_HEADER, key))
+
+        # Validate
+        key_is_valid = False
+        try:
+            # Validate key by quick regex match before parsing by base64
+            # module. Because base64 module skips invalid characters, we have
+            # to do this in advance to make this server strictly reject illegal
+            # keys.
+            if _SEC_WEBSOCKET_KEY_REGEX.match(key):
+                decoded_key = base64.b64decode(key)
+                if len(decoded_key) == 16:
+                    key_is_valid = True
+        except TypeError, e:
+            pass
+
+        if not key_is_valid:
+            raise HandshakeException(
+                'Illegal value for header %s: %r' %
+                (common.SEC_WEBSOCKET_KEY_HEADER, key))
+
+        return decoded_key
+
+    def _get_key(self):
+        key = get_mandatory_header(
+            self._request, common.SEC_WEBSOCKET_KEY_HEADER)
+
+        decoded_key = self._validate_key(key)
+
+        self._logger.debug(
+            '%s: %r (%s)',
+            common.SEC_WEBSOCKET_KEY_HEADER,
+            key,
+            util.hexify(decoded_key))
+
+        return key
+
+    def _create_stream(self, stream_options):
+        return Stream(self._request, stream_options)
+
+    def _create_handshake_response(self, accept):
+        response = []
+
+        response.append('HTTP/1.1 101 Switching Protocols\r\n')
+
+        response.append(format_header(
+            common.UPGRADE_HEADER, common.WEBSOCKET_UPGRADE_TYPE))
+        response.append(format_header(
+            common.CONNECTION_HEADER, common.UPGRADE_CONNECTION_TYPE))
+        response.append(format_header(
+            common.SEC_WEBSOCKET_ACCEPT_HEADER, accept))
+        if self._request.ws_protocol is not None:
+            response.append(format_header(
+                common.SEC_WEBSOCKET_PROTOCOL_HEADER,
+                self._request.ws_protocol))
+        if (self._request.ws_extensions is not None and
+            len(self._request.ws_extensions) != 0):
+            response.append(format_header(
+                common.SEC_WEBSOCKET_EXTENSIONS_HEADER,
+                common.format_extensions(self._request.ws_extensions)))
+        response.append('\r\n')
+
+        return ''.join(response)
+
+    def _send_handshake(self, accept):
+        raw_response = self._create_handshake_response(accept)
+        self._request.connection.write(raw_response)
+        self._logger.debug('Sent server\'s opening handshake: %r',
+                           raw_response)
+
+
+# vi:sts=4 sw=4 et
diff --git a/module/lib/mod_pywebsocket/handshake/hybi00.py b/module/lib/mod_pywebsocket/handshake/hybi00.py
new file mode 100644
index 000000000..cc6f8dc43
--- /dev/null
+++ b/module/lib/mod_pywebsocket/handshake/hybi00.py
@@ -0,0 +1,242 @@
+# Copyright 2011, Google Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+"""This file provides the opening handshake processor for the WebSocket
+protocol version HyBi 00.
+
+Specification:
+http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-00
+"""
+
+
+# Note: request.connection.write/read are used in this module, even though
+# mod_python document says that they should be used only in connection
+# handlers. Unfortunately, we have no other options. For example,
+# request.write/read are not suitable because they don't allow direct raw bytes
+# writing/reading.
+
+
+import logging
+import re
+import struct
+
+from mod_pywebsocket import common
+from mod_pywebsocket.stream import StreamHixie75
+from mod_pywebsocket import util
+from mod_pywebsocket.handshake._base import HandshakeException
+from mod_pywebsocket.handshake._base import build_location
+from mod_pywebsocket.handshake._base import check_header_lines
+from mod_pywebsocket.handshake._base import format_header
+from mod_pywebsocket.handshake._base import get_mandatory_header
+from mod_pywebsocket.handshake._base import validate_subprotocol
+
+
+_MANDATORY_HEADERS = [
+    # key, expected value or None
+    [common.UPGRADE_HEADER, common.WEBSOCKET_UPGRADE_TYPE_HIXIE75],
+    [common.CONNECTION_HEADER, common.UPGRADE_CONNECTION_TYPE],
+]
+
+
+class Handshaker(object):
+    """Opening handshake processor for the WebSocket protocol version HyBi 00.
+    """
+
+    def __init__(self, request, dispatcher):
+        """Construct an instance.
+
+        Args:
+            request: mod_python request.
+            dispatcher: Dispatcher (dispatch.Dispatcher).
+
+        Handshaker will add attributes such as ws_resource in performing
+        handshake.
+        """
+
+        self._logger = util.get_class_logger(self)
+
+        self._request = request
+        self._dispatcher = dispatcher
+
+    def do_handshake(self):
+        """Perform WebSocket Handshake.
+
+        On _request, we set
+            ws_resource, ws_protocol, ws_location, ws_origin, ws_challenge,
+            ws_challenge_md5: WebSocket handshake information.
+            ws_stream: Frame generation/parsing class.
+            ws_version: Protocol version.
+
+        Raises:
+            HandshakeException: when any error happened in parsing the opening
+                                handshake request.
+        """
+
+        # 5.1 Reading the client's opening handshake.
+        # dispatcher sets it in self._request.
+        check_header_lines(self._request, _MANDATORY_HEADERS)
+        self._set_resource()
+        self._set_subprotocol()
+        self._set_location()
+        self._set_origin()
+        self._set_challenge_response()
+        self._set_protocol_version()
+
+        self._dispatcher.do_extra_handshake(self._request)
+
+        self._send_handshake()
+
+    def _set_resource(self):
+        self._request.ws_resource = self._request.uri
+
+    def _set_subprotocol(self):
+        # |Sec-WebSocket-Protocol|
+        subprotocol = self._request.headers_in.get(
+            common.SEC_WEBSOCKET_PROTOCOL_HEADER)
+        if subprotocol is not None:
+            validate_subprotocol(subprotocol, hixie=True)
+        self._request.ws_protocol = subprotocol
+
+    def _set_location(self):
+        # |Host|
+        host = self._request.headers_in.get(common.HOST_HEADER)
+        if host is not None:
+            self._request.ws_location = build_location(self._request)
+        # TODO(ukai): check host is this host.
+
+    def _set_origin(self):
+        # |Origin|
+        origin = self._request.headers_in.get(common.ORIGIN_HEADER)
+        if origin is not None:
+            self._request.ws_origin = origin
+
+    def _set_protocol_version(self):
+        # |Sec-WebSocket-Draft|
+        draft = self._request.headers_in.get(common.SEC_WEBSOCKET_DRAFT_HEADER)
+        if draft is not None and draft != '0':
+            raise HandshakeException('Illegal value for %s: %s' %
+                                     (common.SEC_WEBSOCKET_DRAFT_HEADER,
+                                      draft))
+
+        self._logger.debug('Protocol version is HyBi 00')
+        self._request.ws_version = common.VERSION_HYBI00
+        self._request.ws_stream = StreamHixie75(self._request, True)
+
+    def _set_challenge_response(self):
+        # 5.2 4-8.
+        self._request.ws_challenge = self._get_challenge()
+        # 5.2 9. let /response/ be the MD5 finterprint of /challenge/
+        self._request.ws_challenge_md5 = util.md5_hash(
+            self._request.ws_challenge).digest()
+        self._logger.debug(
+            'Challenge: %r (%s)',
+            self._request.ws_challenge,
+            util.hexify(self._request.ws_challenge))
+        self._logger.debug(
+            'Challenge response: %r (%s)',
+            self._request.ws_challenge_md5,
+            util.hexify(self._request.ws_challenge_md5))
+
+    def _get_key_value(self, key_field):
+        key_value = get_mandatory_header(self._request, key_field)
+
+        self._logger.debug('%s: %r', key_field, key_value)
+
+        # 5.2 4. let /key-number_n/ be the digits (characters in the range
+        # U+0030 DIGIT ZERO (0) to U+0039 DIGIT NINE (9)) in /key_n/,
+        # interpreted as a base ten integer, ignoring all other characters
+        # in /key_n/.
+        try:
+            key_number = int(re.sub("\\D", "", key_value))
+        except:
+            raise HandshakeException('%s field contains no digit' % key_field)
+        # 5.2 5. let /spaces_n/ be the number of U+0020 SPACE characters
+        # in /key_n/.
+        spaces = re.subn(" ", "", key_value)[1]
+        if spaces == 0:
+            raise HandshakeException('%s field contains no space' % key_field)
+
+        self._logger.debug(
+            '%s: Key-number is %d and number of spaces is %d',
+            key_field, key_number, spaces)
+
+        # 5.2 6. if /key-number_n/ is not an integral multiple of /spaces_n/
+        # then abort the WebSocket connection.
+        if key_number % spaces != 0:
+            raise HandshakeException(
+                '%s: Key-number (%d) is not an integral multiple of spaces '
+                '(%d)' % (key_field, key_number, spaces))
+        # 5.2 7. let /part_n/ be /key-number_n/ divided by /spaces_n/.
+        part = key_number / spaces
+        self._logger.debug('%s: Part is %d', key_field, part)
+        return part
+
+    def _get_challenge(self):
+        # 5.2 4-7.
+        key1 = self._get_key_value(common.SEC_WEBSOCKET_KEY1_HEADER)
+        key2 = self._get_key_value(common.SEC_WEBSOCKET_KEY2_HEADER)
+        # 5.2 8. let /challenge/ be the concatenation of /part_1/,
+        challenge = ''
+        challenge += struct.pack('!I', key1)  # network byteorder int
+        challenge += struct.pack('!I', key2)  # network byteorder int
+        challenge += self._request.connection.read(8)
+        return challenge
+
+    def _send_handshake(self):
+        response = []
+
+        # 5.2 10. send the following line.
+        response.append('HTTP/1.1 101 WebSocket Protocol Handshake\r\n')
+
+        # 5.2 11. send the following fields to the client.
+        response.append(format_header(
+            common.UPGRADE_HEADER, common.WEBSOCKET_UPGRADE_TYPE_HIXIE75))
+        response.append(format_header(
+            common.CONNECTION_HEADER, common.UPGRADE_CONNECTION_TYPE))
+        response.append(format_header(
+            common.SEC_WEBSOCKET_LOCATION_HEADER, self._request.ws_location))
+        response.append(format_header(
+            common.SEC_WEBSOCKET_ORIGIN_HEADER, self._request.ws_origin))
+        if self._request.ws_protocol:
+            response.append(format_header(
+                common.SEC_WEBSOCKET_PROTOCOL_HEADER,
+                self._request.ws_protocol))
+        # 5.2 12. send two bytes 0x0D 0x0A.
+        response.append('\r\n')
+        # 5.2 13. send /response/
+        response.append(self._request.ws_challenge_md5)
+
+        raw_response = ''.join(response)
+        self._request.connection.write(raw_response)
+        self._logger.debug('Sent server\'s opening handshake: %r',
+                           raw_response)
+
+
+# vi:sts=4 sw=4 et
diff --git a/module/lib/mod_pywebsocket/headerparserhandler.py b/module/lib/mod_pywebsocket/headerparserhandler.py
new file mode 100644
index 000000000..2cc62de04
--- /dev/null
+++ b/module/lib/mod_pywebsocket/headerparserhandler.py
@@ -0,0 +1,244 @@
+# Copyright 2011, Google Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+"""PythonHeaderParserHandler for mod_pywebsocket.
+
+Apache HTTP Server and mod_python must be configured such that this
+function is called to handle WebSocket request.
+"""
+
+
+import logging
+
+from mod_python import apache
+
+from mod_pywebsocket import common
+from mod_pywebsocket import dispatch
+from mod_pywebsocket import handshake
+from mod_pywebsocket import util
+
+
+# PythonOption to specify the handler root directory.
+_PYOPT_HANDLER_ROOT = 'mod_pywebsocket.handler_root'
+
+# PythonOption to specify the handler scan directory.
+# This must be a directory under the root directory.
+# The default is the root directory.
+_PYOPT_HANDLER_SCAN = 'mod_pywebsocket.handler_scan'
+
+# PythonOption to allow handlers whose canonical path is
+# not under the root directory. It's disallowed by default.
+# Set this option with value of 'yes' to allow.
+_PYOPT_ALLOW_HANDLERS_OUTSIDE_ROOT = (
+    'mod_pywebsocket.allow_handlers_outside_root_dir')
+# Map from values to their meanings. 'Yes' and 'No' are allowed just for
+# compatibility.
+_PYOPT_ALLOW_HANDLERS_OUTSIDE_ROOT_DEFINITION = {
+    'off': False, 'no': False, 'on': True, 'yes': True}
+
+# (Obsolete option. Ignored.)
+# PythonOption to specify to allow handshake defined in Hixie 75 version
+# protocol. The default is None (Off)
+_PYOPT_ALLOW_DRAFT75 = 'mod_pywebsocket.allow_draft75'
+# Map from values to their meanings.
+_PYOPT_ALLOW_DRAFT75_DEFINITION = {'off': False, 'on': True}
+
+
+class ApacheLogHandler(logging.Handler):
+    """Wrapper logging.Handler to emit log message to apache's error.log."""
+
+    _LEVELS = {
+        logging.DEBUG: apache.APLOG_DEBUG,
+        logging.INFO: apache.APLOG_INFO,
+        logging.WARNING: apache.APLOG_WARNING,
+        logging.ERROR: apache.APLOG_ERR,
+        logging.CRITICAL: apache.APLOG_CRIT,
+        }
+
+    def __init__(self, request=None):
+        logging.Handler.__init__(self)
+        self._log_error = apache.log_error
+        if request is not None:
+            self._log_error = request.log_error
+
+        # Time and level will be printed by Apache.
+        self._formatter = logging.Formatter('%(name)s: %(message)s')
+
+    def emit(self, record):
+        apache_level = apache.APLOG_DEBUG
+        if record.levelno in ApacheLogHandler._LEVELS:
+            apache_level = ApacheLogHandler._LEVELS[record.levelno]
+
+        msg = self._formatter.format(record)
+
+        # "server" parameter must be passed to have "level" parameter work.
+        # If only "level" parameter is passed, nothing shows up on Apache's
+        # log. However, at this point, we cannot get the server object of the
+        # virtual host which will process WebSocket requests. The only server
+        # object we can get here is apache.main_server. But Wherever (server
+        # configuration context or virtual host context) we put
+        # PythonHeaderParserHandler directive, apache.main_server just points
+        # the main server instance (not any of virtual server instance). Then,
+        # Apache follows LogLevel directive in the server configuration context
+        # to filter logs. So, we need to specify LogLevel in the server
+        # configuration context. Even if we specify "LogLevel debug" in the
+        # virtual host context which actually handles WebSocket connections,
+        # DEBUG level logs never show up unless "LogLevel debug" is specified
+        # in the server configuration context.
+        #
+        # TODO(tyoshino): Provide logging methods on request object. When
+        # request is mp_request object (when used together with Apache), the
+        # methods call request.log_error indirectly. When request is
+        # _StandaloneRequest, the methods call Python's logging facility which
+        # we create in standalone.py.
+        self._log_error(msg, apache_level, apache.main_server)
+
+
+def _configure_logging():
+    logger = logging.getLogger()
+    # Logs are filtered by Apache based on LogLevel directive in Apache
+    # configuration file. We must just pass logs for all levels to
+    # ApacheLogHandler.
+    logger.setLevel(logging.DEBUG)
+    logger.addHandler(ApacheLogHandler())
+
+
+_configure_logging()
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def _parse_option(name, value, definition):
+    if value is None:
+        return False
+
+    meaning = definition.get(value.lower())
+    if meaning is None:
+        raise Exception('Invalid value for PythonOption %s: %r' %
+                        (name, value))
+    return meaning
+
+
+def _create_dispatcher():
+    _LOGGER.info('Initializing Dispatcher')
+
+    options = apache.main_server.get_options()
+
+    handler_root = options.get(_PYOPT_HANDLER_ROOT, None)
+    if not handler_root:
+        raise Exception('PythonOption %s is not defined' % _PYOPT_HANDLER_ROOT,
+                        apache.APLOG_ERR)
+
+    handler_scan = options.get(_PYOPT_HANDLER_SCAN, handler_root)
+
+    allow_handlers_outside_root = _parse_option(
+        _PYOPT_ALLOW_HANDLERS_OUTSIDE_ROOT,
+        options.get(_PYOPT_ALLOW_HANDLERS_OUTSIDE_ROOT),
+        _PYOPT_ALLOW_HANDLERS_OUTSIDE_ROOT_DEFINITION)
+
+    dispatcher = dispatch.Dispatcher(
+        handler_root, handler_scan, allow_handlers_outside_root)
+
+    for warning in dispatcher.source_warnings():
+        apache.log_error('mod_pywebsocket: %s' % warning, apache.APLOG_WARNING)
+
+    return dispatcher
+
+
+# Initialize
+_dispatcher = _create_dispatcher()
+
+
+def headerparserhandler(request):
+    """Handle request.
+
+    Args:
+        request: mod_python request.
+
+    This function is named headerparserhandler because it is the default
+    name for a PythonHeaderParserHandler.
+    """
+
+    handshake_is_done = False
+    try:
+        # Fallback to default http handler for request paths for which
+        # we don't have request handlers.
+        if not _dispatcher.get_handler_suite(request.uri):
+            request.log_error('No handler for resource: %r' % request.uri,
+                              apache.APLOG_INFO)
+            request.log_error('Fallback to Apache', apache.APLOG_INFO)
+            return apache.DECLINED
+    except dispatch.DispatchException, e:
+        request.log_error('mod_pywebsocket: %s' % e, apache.APLOG_INFO)
+        if not handshake_is_done:
+            return e.status
+
+    try:
+        allow_draft75 = _parse_option(
+            _PYOPT_ALLOW_DRAFT75,
+            apache.main_server.get_options().get(_PYOPT_ALLOW_DRAFT75),
+            _PYOPT_ALLOW_DRAFT75_DEFINITION)
+
+        try:
+            handshake.do_handshake(
+                request, _dispatcher, allowDraft75=allow_draft75)
+        except handshake.VersionException, e:
+            request.log_error('mod_pywebsocket: %s' % e, apache.APLOG_INFO)
+            request.err_headers_out.add(common.SEC_WEBSOCKET_VERSION_HEADER,
+                                        e.supported_versions)
+            return apache.HTTP_BAD_REQUEST
+        except handshake.HandshakeException, e:
+            # Handshake for ws/wss failed.
+            # Send http response with error status.
+            request.log_error('mod_pywebsocket: %s' % e, apache.APLOG_INFO)
+            return e.status
+
+        handshake_is_done = True
+        request._dispatcher = _dispatcher
+        _dispatcher.transfer_data(request)
+    except handshake.AbortedByUserException, e:
+        request.log_error('mod_pywebsocket: %s' % e, apache.APLOG_INFO)
+    except Exception, e:
+        # DispatchException can also be thrown if something is wrong in
+        # pywebsocket code. It's caught here, then.
+
+        request.log_error('mod_pywebsocket: %s\n%s' %
+                          (e, util.get_stack_trace()),
+                          apache.APLOG_ERR)
+        # Unknown exceptions before handshake mean Apache must handle its
+        # request with another handler.
+        if not handshake_is_done:
+            return apache.DECLINED
+    # Set assbackwards to suppress response header generation by Apache.
+    request.assbackwards = 1
+    return apache.DONE  # Return DONE such that no other handlers are invoked.
+
+
+# vi:sts=4 sw=4 et
diff --git a/module/lib/mod_pywebsocket/http_header_util.py b/module/lib/mod_pywebsocket/http_header_util.py
new file mode 100644
index 000000000..b77465393
--- /dev/null
+++ b/module/lib/mod_pywebsocket/http_header_util.py
@@ -0,0 +1,263 @@
+# Copyright 2011, Google Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+"""Utilities for parsing and formatting headers that follow the grammar defined
+in HTTP RFC http://www.ietf.org/rfc/rfc2616.txt.
+"""
+
+
+import urlparse
+
+
+_SEPARATORS = '()<>@,;:\\"/[]?={} \t'
+
+
+def _is_char(c):
+    """Returns true iff c is in CHAR as specified in HTTP RFC."""
+
+    return ord(c) <= 127
+
+
+def _is_ctl(c):
+    """Returns true iff c is in CTL as specified in HTTP RFC."""
+
+    return ord(c) <= 31 or ord(c) == 127
+
+
+class ParsingState(object):
+
+    def __init__(self, data):
+        self.data = data
+        self.head = 0
+
+
+def peek(state, pos=0):
+    """Peeks the character at pos from the head of data."""
+
+    if state.head + pos >= len(state.data):
+        return None
+
+    return state.data[state.head + pos]
+
+
+def consume(state, amount=1):
+    """Consumes specified amount of bytes from the head and returns the
+    consumed bytes. If there's not enough bytes to consume, returns None.
+    """
+
+    if state.head + amount > len(state.data):
+        return None
+
+    result = state.data[state.head:state.head + amount]
+    state.head = state.head + amount
+    return result
+
+
+def consume_string(state, expected):
+    """Given a parsing state and a expected string, consumes the string from
+    the head. Returns True if consumed successfully. Otherwise, returns
+    False.
+    """
+
+    pos = 0
+
+    for c in expected:
+        if c != peek(state, pos):
+            return False
+        pos += 1
+
+    consume(state, pos)
+    return True
+
+
+def consume_lws(state):
+    """Consumes a LWS from the head. Returns True if any LWS is consumed.
+    Otherwise, returns False.
+
+    LWS = [CRLF] 1*( SP | HT )
+    """
+
+    original_head = state.head
+
+    consume_string(state, '\r\n')
+
+    pos = 0
+
+    while True:
+        c = peek(state, pos)
+        if c == ' ' or c == '\t':
+            pos += 1
+        else:
+            if pos == 0:
+                state.head = original_head
+                return False
+            else:
+                consume(state, pos)
+                return True
+
+
+def consume_lwses(state):
+    """Consumes *LWS from the head."""
+
+    while consume_lws(state):
+        pass
+
+
+def consume_token(state):
+    """Consumes a token from the head. Returns the token or None if no token
+    was found.
+    """
+
+    pos = 0
+
+    while True:
+        c = peek(state, pos)
+        if c is None or c in _SEPARATORS or _is_ctl(c) or not _is_char(c):
+            if pos == 0:
+                return None
+
+            return consume(state, pos)
+        else:
+            pos += 1
+
+
+def consume_token_or_quoted_string(state):
+    """Consumes a token or a quoted-string, and returns the token or unquoted
+    string. If no token or quoted-string was found, returns None.
+    """
+
+    original_head = state.head
+
+    if not consume_string(state, '"'):
+        return consume_token(state)
+
+    result = []
+
+    expect_quoted_pair = False
+
+    while True:
+        if not expect_quoted_pair and consume_lws(state):
+            result.append(' ')
+            continue
+
+        c = consume(state)
+        if c is None:
+            # quoted-string is not enclosed with double quotation
+            state.head = original_head
+            return None
+        elif expect_quoted_pair:
+            expect_quoted_pair = False
+            if _is_char(c):
+                result.append(c)
+            else:
+                # Non CHAR character found in quoted-pair
+                state.head = original_head
+                return None
+        elif c == '\\':
+            expect_quoted_pair = True
+        elif c == '"':
+            return ''.join(result)
+        elif _is_ctl(c):
+            # Invalid character %r found in qdtext
+            state.head = original_head
+            return None
+        else:
+            result.append(c)
+
+
+def quote_if_necessary(s):
+    """Quotes arbitrary string into quoted-string."""
+
+    quote = False
+    if s == '':
+        return '""'
+
+    result = []
+    for c in s:
+        if c == '"' or c in _SEPARATORS or _is_ctl(c) or not _is_char(c):
+            quote = True
+
+        if c == '"' or _is_ctl(c):
+            result.append('\\' + c)
+        else:
+            result.append(c)
+
+    if quote:
+        return '"' + ''.join(result) + '"'
+    else:
+        return ''.join(result)
+
+
+def parse_uri(uri):
+    """Parse absolute URI then return host, port and resource."""
+
+    parsed = urlparse.urlsplit(uri)
+    if parsed.scheme != 'wss' and parsed.scheme != 'ws':
+        # |uri| must be a relative URI.
+        # TODO(toyoshim): Should validate |uri|.
+        return None, None, uri
+
+    if parsed.hostname is None:
+        return None, None, None
+
+    port = None
+    try:
+        port = parsed.port
+    except ValueError, e:
+        # port property cause ValueError on invalid null port description like
+        # 'ws://host:/path'.
+        return None, None, None
+
+    if port is None:
+        if parsed.scheme == 'ws':
+            port = 80
+        else:
+            port = 443
+
+    path = parsed.path
+    if not path:
+        path += '/'
+    if parsed.query:
+        path += '?' + parsed.query
+    if parsed.fragment:
+        path += '#' + parsed.fragment
+
+    return parsed.hostname, port, path
+
+
+try:
+    urlparse.uses_netloc.index('ws')
+except ValueError, e:
+    # urlparse in Python2.5.1 doesn't have 'ws' and 'wss' entries.
+    urlparse.uses_netloc.append('ws')
+    urlparse.uses_netloc.append('wss')
+
+
+# vi:sts=4 sw=4 et
diff --git a/module/lib/mod_pywebsocket/memorizingfile.py b/module/lib/mod_pywebsocket/memorizingfile.py
new file mode 100644
index 000000000..4d4cd9585
--- /dev/null
+++ b/module/lib/mod_pywebsocket/memorizingfile.py
@@ -0,0 +1,99 @@
+#!/usr/bin/env python
+#
+# Copyright 2011, Google Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+"""Memorizing file.
+
+A memorizing file wraps a file and memorizes lines read by readline.
+"""
+
+
+import sys
+
+
+class MemorizingFile(object):
+    """MemorizingFile wraps a file and memorizes lines read by readline.
+
+    Note that data read by other methods are not memorized. This behavior
+    is good enough for memorizing lines SimpleHTTPServer reads before
+    the control reaches WebSocketRequestHandler.
+    """
+
+    def __init__(self, file_, max_memorized_lines=sys.maxint):
+        """Construct an instance.
+
+        Args:
+            file_: the file object to wrap.
+            max_memorized_lines: the maximum number of lines to memorize.
+                Only the first max_memorized_lines are memorized.
+                Default: sys.maxint.
+        """
+
+        self._file = file_
+        self._memorized_lines = []
+        self._max_memorized_lines = max_memorized_lines
+        self._buffered = False
+        self._buffered_line = None
+
+    def __getattribute__(self, name):
+        if name in ('_file', '_memorized_lines', '_max_memorized_lines',
+                    '_buffered', '_buffered_line', 'readline',
+                    'get_memorized_lines'):
+            return object.__getattribute__(self, name)
+        return self._file.__getattribute__(name)
+
+    def readline(self, size=-1):
+        """Override file.readline and memorize the line read.
+
+        Note that even if size is specified and smaller than actual size,
+        the whole line will be read out from underlying file object by
+        subsequent readline calls.
+        """
+
+        if self._buffered:
+            line = self._buffered_line
+            self._buffered = False
+        else:
+            line = self._file.readline()
+            if line and len(self._memorized_lines) < self._max_memorized_lines:
+                self._memorized_lines.append(line)
+        if size >= 0 and size < len(line):
+            self._buffered = True
+            self._buffered_line = line[size:]
+            return line[:size]
+        return line
+
+    def get_memorized_lines(self):
+        """Get lines memorized so far."""
+        return self._memorized_lines
+
+
+# vi:sts=4 sw=4 et
diff --git a/module/lib/mod_pywebsocket/msgutil.py b/module/lib/mod_pywebsocket/msgutil.py
new file mode 100644
index 000000000..4c1a0114b
--- /dev/null
+++ b/module/lib/mod_pywebsocket/msgutil.py
@@ -0,0 +1,219 @@
+# Copyright 2011, Google Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+"""Message related utilities.
+
+Note: request.connection.write/read are used in this module, even though
+mod_python document says that they should be used only in connection
+handlers. Unfortunately, we have no other options. For example,
+request.write/read are not suitable because they don't allow direct raw
+bytes writing/reading.
+"""
+
+
+import Queue
+import threading
+
+
+# Export Exception symbols from msgutil for backward compatibility
+from mod_pywebsocket._stream_base import ConnectionTerminatedException
+from mod_pywebsocket._stream_base import InvalidFrameException
+from mod_pywebsocket._stream_base import BadOperationException
+from mod_pywebsocket._stream_base import UnsupportedFrameException
+
+
+# An API for handler to send/receive WebSocket messages.
+def close_connection(request):
+    """Close connection.
+
+    Args:
+        request: mod_python request.
+    """
+    request.ws_stream.close_connection()
+
+
+def send_message(request, payload_data, end=True, binary=False):
+    """Send a message (or part of a message).
+
+    Args:
+        request: mod_python request.
+        payload_data: unicode text or str binary to send.
+        end: True to terminate a message.
+             False to send payload_data as part of a message that is to be
+             terminated by next or later send_message call with end=True.
+        binary: send payload_data as binary frame(s).
+    Raises:
+        BadOperationException: when server already terminated.
+    """
+    request.ws_stream.send_message(payload_data, end, binary)
+
+
+def receive_message(request):
+    """Receive a WebSocket frame and return its payload as a text in
+    unicode or a binary in str.
+
+    Args:
+        request: mod_python request.
+    Raises:
+        InvalidFrameException:     when client send invalid frame.
+        UnsupportedFrameException: when client send unsupported frame e.g. some
+                                   of reserved bit is set but no extension can
+                                   recognize it.
+        InvalidUTF8Exception:      when client send a text frame containing any
+                                   invalid UTF-8 string.
+        ConnectionTerminatedException: when the connection is closed
+                                   unexpectedly.
+        BadOperationException:     when client already terminated.
+    """
+    return request.ws_stream.receive_message()
+
+
+def send_ping(request, body=''):
+    request.ws_stream.send_ping(body)
+
+
+class MessageReceiver(threading.Thread):
+    """This class receives messages from the client.
+
+    This class provides three ways to receive messages: blocking,
+    non-blocking, and via callback. Callback has the highest precedence.
+
+    Note: This class should not be used with the standalone server for wss
+    because pyOpenSSL used by the server raises a fatal error if the socket
+    is accessed from multiple threads.
+    """
+
+    def __init__(self, request, onmessage=None):
+        """Construct an instance.
+
+        Args:
+            request: mod_python request.
+            onmessage: a function to be called when a message is received.
+                       May be None. If not None, the function is called on
+                       another thread. In that case, MessageReceiver.receive
+                       and MessageReceiver.receive_nowait are useless
+                       because they will never return any messages.
+        """
+
+        threading.Thread.__init__(self)
+        self._request = request
+        self._queue = Queue.Queue()
+        self._onmessage = onmessage
+        self._stop_requested = False
+        self.setDaemon(True)
+        self.start()
+
+    def run(self):
+        try:
+            while not self._stop_requested:
+                message = receive_message(self._request)
+                if self._onmessage:
+                    self._onmessage(message)
+                else:
+                    self._queue.put(message)
+        finally:
+            close_connection(self._request)
+
+    def receive(self):
+        """ Receive a message from the channel, blocking.
+
+        Returns:
+            message as a unicode string.
+        """
+        return self._queue.get()
+
+    def receive_nowait(self):
+        """ Receive a message from the channel, non-blocking.
+
+        Returns:
+            message as a unicode string if available. None otherwise.
+        """
+        try:
+            message = self._queue.get_nowait()
+        except Queue.Empty:
+            message = None
+        return message
+
+    def stop(self):
+        """Request to stop this instance.
+
+        The instance will be stopped after receiving the next message.
+        This method may not be very useful, but there is no clean way
+        in Python to forcefully stop a running thread.
+        """
+        self._stop_requested = True
+
+
+class MessageSender(threading.Thread):
+    """This class sends messages to the client.
+
+    This class provides both synchronous and asynchronous ways to send
+    messages.
+
+    Note: This class should not be used with the standalone server for wss
+    because pyOpenSSL used by the server raises a fatal error if the socket
+    is accessed from multiple threads.
+    """
+
+    def __init__(self, request):
+        """Construct an instance.
+
+        Args:
+            request: mod_python request.
+        """
+        threading.Thread.__init__(self)
+        self._request = request
+        self._queue = Queue.Queue()
+        self.setDaemon(True)
+        self.start()
+
+    def run(self):
+        while True:
+            message, condition = self._queue.get()
+            condition.acquire()
+            send_message(self._request, message)
+            condition.notify()
+            condition.release()
+
+    def send(self, message):
+        """Send a message, blocking."""
+
+        condition = threading.Condition()
+        condition.acquire()
+        self._queue.put((message, condition))
+        condition.wait()
+
+    def send_nowait(self, message):
+        """Send a message, non-blocking."""
+
+        self._queue.put((message, threading.Condition()))
+
+
+# vi:sts=4 sw=4 et
diff --git a/module/lib/mod_pywebsocket/mux.py b/module/lib/mod_pywebsocket/mux.py
new file mode 100644
index 000000000..f0bdd2461
--- /dev/null
+++ b/module/lib/mod_pywebsocket/mux.py
@@ -0,0 +1,1636 @@
+# Copyright 2012, Google Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+"""This file provides classes and helper functions for multiplexing extension.
+
+Specification:
+http://tools.ietf.org/html/draft-ietf-hybi-websocket-multiplexing-06
+"""
+
+
+import collections
+import copy
+import email
+import email.parser
+import logging
+import math
+import struct
+import threading
+import traceback
+
+from mod_pywebsocket import common
+from mod_pywebsocket import handshake
+from mod_pywebsocket import util
+from mod_pywebsocket._stream_base import BadOperationException
+from mod_pywebsocket._stream_base import ConnectionTerminatedException
+from mod_pywebsocket._stream_hybi import Frame
+from mod_pywebsocket._stream_hybi import Stream
+from mod_pywebsocket._stream_hybi import StreamOptions
+from mod_pywebsocket._stream_hybi import create_binary_frame
+from mod_pywebsocket._stream_hybi import create_closing_handshake_body
+from mod_pywebsocket._stream_hybi import create_header
+from mod_pywebsocket._stream_hybi import create_length_header
+from mod_pywebsocket._stream_hybi import parse_frame
+from mod_pywebsocket.handshake import hybi
+
+
+_CONTROL_CHANNEL_ID = 0
+_DEFAULT_CHANNEL_ID = 1
+
+_MUX_OPCODE_ADD_CHANNEL_REQUEST = 0
+_MUX_OPCODE_ADD_CHANNEL_RESPONSE = 1
+_MUX_OPCODE_FLOW_CONTROL = 2
+_MUX_OPCODE_DROP_CHANNEL = 3
+_MUX_OPCODE_NEW_CHANNEL_SLOT = 4
+
+_MAX_CHANNEL_ID = 2 ** 29 - 1
+
+_INITIAL_NUMBER_OF_CHANNEL_SLOTS = 64
+_INITIAL_QUOTA_FOR_CLIENT = 8 * 1024
+
+_HANDSHAKE_ENCODING_IDENTITY = 0
+_HANDSHAKE_ENCODING_DELTA = 1
+
+# We need only these status code for now.
+_HTTP_BAD_RESPONSE_MESSAGES = {
+    common.HTTP_STATUS_BAD_REQUEST: 'Bad Request',
+}
+
+# DropChannel reason code
+# TODO(bashi): Define all reason code defined in -05 draft.
+_DROP_CODE_NORMAL_CLOSURE = 1000
+
+_DROP_CODE_INVALID_ENCAPSULATING_MESSAGE = 2001
+_DROP_CODE_CHANNEL_ID_TRUNCATED = 2002
+_DROP_CODE_ENCAPSULATED_FRAME_IS_TRUNCATED = 2003
+_DROP_CODE_UNKNOWN_MUX_OPCODE = 2004
+_DROP_CODE_INVALID_MUX_CONTROL_BLOCK = 2005
+_DROP_CODE_CHANNEL_ALREADY_EXISTS = 2006
+_DROP_CODE_NEW_CHANNEL_SLOT_VIOLATION = 2007
+
+_DROP_CODE_UNKNOWN_REQUEST_ENCODING = 3002
+_DROP_CODE_SEND_QUOTA_VIOLATION = 3005
+_DROP_CODE_ACKNOWLEDGED = 3008
+
+
+class MuxUnexpectedException(Exception):
+    """Exception in handling multiplexing extension."""
+    pass
+
+
+# Temporary
+class MuxNotImplementedException(Exception):
+    """Raised when a flow enters unimplemented code path."""
+    pass
+
+
+class LogicalConnectionClosedException(Exception):
+    """Raised when logical connection is gracefully closed."""
+    pass
+
+
+class PhysicalConnectionError(Exception):
+    """Raised when there is a physical connection error."""
+    def __init__(self, drop_code, message=''):
+        super(PhysicalConnectionError, self).__init__(
+            'code=%d, message=%r' % (drop_code, message))
+        self.drop_code = drop_code
+        self.message = message
+
+
+class LogicalChannelError(Exception):
+    """Raised when there is a logical channel error."""
+    def __init__(self, channel_id, drop_code, message=''):
+        super(LogicalChannelError, self).__init__(
+            'channel_id=%d, code=%d, message=%r' % (
+                channel_id, drop_code, message))
+        self.channel_id = channel_id
+        self.drop_code = drop_code
+        self.message = message
+
+
+def _encode_channel_id(channel_id):
+    if channel_id < 0:
+        raise ValueError('Channel id %d must not be negative' % channel_id)
+
+    if channel_id < 2 ** 7:
+        return chr(channel_id)
+    if channel_id < 2 ** 14:
+        return struct.pack('!H', 0x8000 + channel_id)
+    if channel_id < 2 ** 21:
+        first = chr(0xc0 + (channel_id >> 16))
+        return first + struct.pack('!H', channel_id & 0xffff)
+    if channel_id < 2 ** 29:
+        return struct.pack('!L', 0xe0000000 + channel_id)
+
+    raise ValueError('Channel id %d is too large' % channel_id)
+
+
+def _encode_number(number):
+    return create_length_header(number, False)
+
+
+def _create_add_channel_response(channel_id, encoded_handshake,
+                                 encoding=0, rejected=False,
+                                 outer_frame_mask=False):
+    if encoding != 0 and encoding != 1:
+        raise ValueError('Invalid encoding %d' % encoding)
+
+    first_byte = ((_MUX_OPCODE_ADD_CHANNEL_RESPONSE << 5) |
+                  (rejected << 4) | encoding)
+    block = (chr(first_byte) +
+             _encode_channel_id(channel_id) +
+             _encode_number(len(encoded_handshake)) +
+             encoded_handshake)
+    payload = _encode_channel_id(_CONTROL_CHANNEL_ID) + block
+    return create_binary_frame(payload, mask=outer_frame_mask)
+
+
+def _create_drop_channel(channel_id, code=None, message='',
+                         outer_frame_mask=False):
+    if len(message) > 0 and code is None:
+        raise ValueError('Code must be specified if message is specified')
+
+    first_byte = _MUX_OPCODE_DROP_CHANNEL << 5
+    block = chr(first_byte) + _encode_channel_id(channel_id)
+    if code is None:
+        block += _encode_number(0) # Reason size
+    else:
+        reason = struct.pack('!H', code) + message
+        reason_size = _encode_number(len(reason))
+        block += reason_size + reason
+
+    payload = _encode_channel_id(_CONTROL_CHANNEL_ID) + block
+    return create_binary_frame(payload, mask=outer_frame_mask)
+
+
+def _create_flow_control(channel_id, replenished_quota,
+                         outer_frame_mask=False):
+    first_byte = _MUX_OPCODE_FLOW_CONTROL << 5
+    block = (chr(first_byte) +
+             _encode_channel_id(channel_id) +
+             _encode_number(replenished_quota))
+    payload = _encode_channel_id(_CONTROL_CHANNEL_ID) + block
+    return create_binary_frame(payload, mask=outer_frame_mask)
+
+
+def _create_new_channel_slot(slots, send_quota, outer_frame_mask=False):
+    if slots < 0 or send_quota < 0:
+        raise ValueError('slots and send_quota must be non-negative.')
+    first_byte = _MUX_OPCODE_NEW_CHANNEL_SLOT << 5
+    block = (chr(first_byte) +
+             _encode_number(slots) +
+             _encode_number(send_quota))
+    payload = _encode_channel_id(_CONTROL_CHANNEL_ID) + block
+    return create_binary_frame(payload, mask=outer_frame_mask)
+
+
+def _create_fallback_new_channel_slot(outer_frame_mask=False):
+    first_byte = (_MUX_OPCODE_NEW_CHANNEL_SLOT << 5) | 1 # Set the F flag
+    block = (chr(first_byte) + _encode_number(0) + _encode_number(0))
+    payload = _encode_channel_id(_CONTROL_CHANNEL_ID) + block
+    return create_binary_frame(payload, mask=outer_frame_mask)
+
+
+def _parse_request_text(request_text):
+    request_line, header_lines = request_text.split('\r\n', 1)
+
+    words = request_line.split(' ')
+    if len(words) != 3:
+        raise ValueError('Bad Request-Line syntax %r' % request_line)
+    [command, path, version] = words
+    if version != 'HTTP/1.1':
+        raise ValueError('Bad request version %r' % version)
+
+    # email.parser.Parser() parses RFC 2822 (RFC 822) style headers.
+    # RFC 6455 refers RFC 2616 for handshake parsing, and RFC 2616 refers
+    # RFC 822.
+    headers = email.parser.Parser().parsestr(header_lines)
+    return command, path, version, headers
+
+
+class _ControlBlock(object):
+    """A structure that holds parsing result of multiplexing control block.
+    Control block specific attributes will be added by _MuxFramePayloadParser.
+    (e.g. encoded_handshake will be added for AddChannelRequest and
+    AddChannelResponse)
+    """
+
+    def __init__(self, opcode):
+        self.opcode = opcode
+
+
+class _MuxFramePayloadParser(object):
+    """A class that parses multiplexed frame payload."""
+
+    def __init__(self, payload):
+        self._data = payload
+        self._read_position = 0
+        self._logger = util.get_class_logger(self)
+
+    def read_channel_id(self):
+        """Reads channel id.
+
+        Raises:
+            ValueError: when the payload doesn't contain
+                valid channel id.
+        """
+
+        remaining_length = len(self._data) - self._read_position
+        pos = self._read_position
+        if remaining_length == 0:
+            raise ValueError('Invalid channel id format')
+
+        channel_id = ord(self._data[pos])
+        channel_id_length = 1
+        if channel_id & 0xe0 == 0xe0:
+            if remaining_length < 4:
+                raise ValueError('Invalid channel id format')
+            channel_id = struct.unpack('!L',
+                                       self._data[pos:pos+4])[0] & 0x1fffffff
+            channel_id_length = 4
+        elif channel_id & 0xc0 == 0xc0:
+            if remaining_length < 3:
+                raise ValueError('Invalid channel id format')
+            channel_id = (((channel_id & 0x1f) << 16) +
+                          struct.unpack('!H', self._data[pos+1:pos+3])[0])
+            channel_id_length = 3
+        elif channel_id & 0x80 == 0x80:
+            if remaining_length < 2:
+                raise ValueError('Invalid channel id format')
+            channel_id = struct.unpack('!H',
+                                       self._data[pos:pos+2])[0] & 0x3fff
+            channel_id_length = 2
+        self._read_position += channel_id_length
+
+        return channel_id
+
+    def read_inner_frame(self):
+        """Reads an inner frame.
+
+        Raises:
+            PhysicalConnectionError: when the inner frame is invalid.
+        """
+
+        if len(self._data) == self._read_position:
+            raise PhysicalConnectionError(
+                _DROP_CODE_ENCAPSULATED_FRAME_IS_TRUNCATED)
+
+        bits = ord(self._data[self._read_position])
+        self._read_position += 1
+        fin = (bits & 0x80) == 0x80
+        rsv1 = (bits & 0x40) == 0x40
+        rsv2 = (bits & 0x20) == 0x20
+        rsv3 = (bits & 0x10) == 0x10
+        opcode = bits & 0xf
+        payload = self.remaining_data()
+        # Consume rest of the message which is payload data of the original
+        # frame.
+        self._read_position = len(self._data)
+        return fin, rsv1, rsv2, rsv3, opcode, payload
+
+    def _read_number(self):
+        if self._read_position + 1 > len(self._data):
+            raise PhysicalConnectionError(
+                _DROP_CODE_INVALID_MUX_CONTROL_BLOCK,
+                'Cannot read the first byte of number field')
+
+        number = ord(self._data[self._read_position])
+        if number & 0x80 == 0x80:
+            raise PhysicalConnectionError(
+                _DROP_CODE_INVALID_MUX_CONTROL_BLOCK,
+                'The most significant bit of the first byte of number should '
+                'be unset')
+        self._read_position += 1
+        pos = self._read_position
+        if number == 127:
+            if pos + 8 > len(self._data):
+                raise PhysicalConnectionError(
+                    _DROP_CODE_INVALID_MUX_CONTROL_BLOCK,
+                    'Invalid number field')
+            self._read_position += 8
+            number = struct.unpack('!Q', self._data[pos:pos+8])[0]
+            if number > 0x7FFFFFFFFFFFFFFF:
+                raise PhysicalConnectionError(
+                    _DROP_CODE_INVALID_MUX_CONTROL_BLOCK,
+                    'Encoded number >= 2^63')
+            if number <= 0xFFFF:
+                raise PhysicalConnectionError(
+                    _DROP_CODE_INVALID_MUX_CONTROL_BLOCK,
+                    '%d should not be encoded by 9 bytes encoding' % number)
+            return number
+        if number == 126:
+            if pos + 2 > len(self._data):
+                raise PhysicalConnectionError(
+                    _DROP_CODE_INVALID_MUX_CONTROL_BLOCK,
+                    'Invalid number field')
+            self._read_position += 2
+            number = struct.unpack('!H', self._data[pos:pos+2])[0]
+            if number <= 125:
+                raise PhysicalConnectionError(
+                    _DROP_CODE_INVALID_MUX_CONTROL_BLOCK,
+                    '%d should not be encoded by 3 bytes encoding' % number)
+        return number
+
+    def _read_size_and_contents(self):
+        """Reads data that consists of followings:
+            - the size of the contents encoded the same way as payload length
+              of the WebSocket Protocol with 1 bit padding at the head.
+            - the contents.
+        """
+
+        size = self._read_number()
+        pos = self._read_position
+        if pos + size > len(self._data):
+            raise PhysicalConnectionError(
+                _DROP_CODE_INVALID_MUX_CONTROL_BLOCK,
+                'Cannot read %d bytes data' % size)
+
+        self._read_position += size
+        return self._data[pos:pos+size]
+
+    def _read_add_channel_request(self, first_byte, control_block):
+        reserved = (first_byte >> 2) & 0x7
+        if reserved != 0:
+            raise PhysicalConnectionError(
+                _DROP_CODE_INVALID_MUX_CONTROL_BLOCK,
+                'Reserved bits must be unset')
+
+        # Invalid encoding will be handled by MuxHandler.
+        encoding = first_byte & 0x3
+        try:
+            control_block.channel_id = self.read_channel_id()
+        except ValueError, e:
+            raise PhysicalConnectionError(_DROP_CODE_INVALID_MUX_CONTROL_BLOCK)
+        control_block.encoding = encoding
+        encoded_handshake = self._read_size_and_contents()
+        control_block.encoded_handshake = encoded_handshake
+        return control_block
+
+    def _read_add_channel_response(self, first_byte, control_block):
+        reserved = (first_byte >> 2) & 0x3
+        if reserved != 0:
+            raise PhysicalConnectionError(
+                _DROP_CODE_INVALID_MUX_CONTROL_BLOCK,
+                'Reserved bits must be unset')
+
+        control_block.accepted = (first_byte >> 4) & 1
+        control_block.encoding = first_byte & 0x3
+        try:
+            control_block.channel_id = self.read_channel_id()
+        except ValueError, e:
+            raise PhysicalConnectionError(_DROP_CODE_INVALID_MUX_CONTROL_BLOCK)
+        control_block.encoded_handshake = self._read_size_and_contents()
+        return control_block
+
+    def _read_flow_control(self, first_byte, control_block):
+        reserved = first_byte & 0x1f
+        if reserved != 0:
+            raise PhysicalConnectionError(
+                _DROP_CODE_INVALID_MUX_CONTROL_BLOCK,
+                'Reserved bits must be unset')
+
+        try:
+            control_block.channel_id = self.read_channel_id()
+        except ValueError, e:
+            raise PhysicalConnectionError(_DROP_CODE_INVALID_MUX_CONTROL_BLOCK)
+        control_block.send_quota = self._read_number()
+        return control_block
+
+    def _read_drop_channel(self, first_byte, control_block):
+        reserved = first_byte & 0x1f
+        if reserved != 0:
+            raise PhysicalConnectionError(
+                _DROP_CODE_INVALID_MUX_CONTROL_BLOCK,
+                'Reserved bits must be unset')
+
+        try:
+            control_block.channel_id = self.read_channel_id()
+        except ValueError, e:
+            raise PhysicalConnectionError(_DROP_CODE_INVALID_MUX_CONTROL_BLOCK)
+        reason = self._read_size_and_contents()
+        if len(reason) == 0:
+            control_block.drop_code = None
+            control_block.drop_message = ''
+        elif len(reason) >= 2:
+            control_block.drop_code = struct.unpack('!H', reason[:2])[0]
+            control_block.drop_message = reason[2:]
+        else:
+            raise PhysicalConnectionError(
+                _DROP_CODE_INVALID_MUX_CONTROL_BLOCK,
+                'Received DropChannel that conains only 1-byte reason')
+        return control_block
+
+    def _read_new_channel_slot(self, first_byte, control_block):
+        reserved = first_byte & 0x1e
+        if reserved != 0:
+            raise PhysicalConnectionError(
+                _DROP_CODE_INVALID_MUX_CONTROL_BLOCK,
+                'Reserved bits must be unset')
+        control_block.fallback = first_byte & 1
+        control_block.slots = self._read_number()
+        control_block.send_quota = self._read_number()
+        return control_block
+
+    def read_control_blocks(self):
+        """Reads control block(s).
+
+        Raises:
+           PhysicalConnectionError: when the payload contains invalid control
+               block(s).
+           StopIteration: when no control blocks left.
+        """
+
+        while self._read_position < len(self._data):
+            first_byte = ord(self._data[self._read_position])
+            self._read_position += 1
+            opcode = (first_byte >> 5) & 0x7
+            control_block = _ControlBlock(opcode=opcode)
+            if opcode == _MUX_OPCODE_ADD_CHANNEL_REQUEST:
+                yield self._read_add_channel_request(first_byte, control_block)
+            elif opcode == _MUX_OPCODE_ADD_CHANNEL_RESPONSE:
+                yield self._read_add_channel_response(
+                    first_byte, control_block)
+            elif opcode == _MUX_OPCODE_FLOW_CONTROL:
+                yield self._read_flow_control(first_byte, control_block)
+            elif opcode == _MUX_OPCODE_DROP_CHANNEL:
+                yield self._read_drop_channel(first_byte, control_block)
+            elif opcode == _MUX_OPCODE_NEW_CHANNEL_SLOT:
+                yield self._read_new_channel_slot(first_byte, control_block)
+            else:
+                raise PhysicalConnectionError(
+                    _DROP_CODE_UNKNOWN_MUX_OPCODE,
+                    'Invalid opcode %d' % opcode)
+
+        assert self._read_position == len(self._data)
+        raise StopIteration
+
+    def remaining_data(self):
+        """Returns remaining data."""
+
+        return self._data[self._read_position:]
+
+
+class _LogicalRequest(object):
+    """Mimics mod_python request."""
+
+    def __init__(self, channel_id, command, path, protocol, headers,
+                 connection):
+        """Constructs an instance.
+
+        Args:
+            channel_id: the channel id of the logical channel.
+            command: HTTP request command.
+            path: HTTP request path.
+            headers: HTTP headers.
+            connection: _LogicalConnection instance.
+        """
+
+        self.channel_id = channel_id
+        self.method = command
+        self.uri = path
+        self.protocol = protocol
+        self.headers_in = headers
+        self.connection = connection
+        self.server_terminated = False
+        self.client_terminated = False
+
+    def is_https(self):
+        """Mimics request.is_https(). Returns False because this method is
+        used only by old protocols (hixie and hybi00).
+        """
+
+        return False
+
+
+class _LogicalConnection(object):
+    """Mimics mod_python mp_conn."""
+
+    # For details, see the comment of set_read_state().
+    STATE_ACTIVE = 1
+    STATE_GRACEFULLY_CLOSED = 2
+    STATE_TERMINATED = 3
+
+    def __init__(self, mux_handler, channel_id):
+        """Constructs an instance.
+
+        Args:
+            mux_handler: _MuxHandler instance.
+            channel_id: channel id of this connection.
+        """
+
+        self._mux_handler = mux_handler
+        self._channel_id = channel_id
+        self._incoming_data = ''
+        self._write_condition = threading.Condition()
+        self._waiting_write_completion = False
+        self._read_condition = threading.Condition()
+        self._read_state = self.STATE_ACTIVE
+
+    def get_local_addr(self):
+        """Getter to mimic mp_conn.local_addr."""
+
+        return self._mux_handler.physical_connection.get_local_addr()
+    local_addr = property(get_local_addr)
+
+    def get_remote_addr(self):
+        """Getter to mimic mp_conn.remote_addr."""
+
+        return self._mux_handler.physical_connection.get_remote_addr()
+    remote_addr = property(get_remote_addr)
+
+    def get_memorized_lines(self):
+        """Gets memorized lines. Not supported."""
+
+        raise MuxUnexpectedException('_LogicalConnection does not support '
+                                     'get_memorized_lines')
+
+    def write(self, data):
+        """Writes data. mux_handler sends data asynchronously. The caller will
+        be suspended until write done.
+
+        Args:
+            data: data to be written.
+
+        Raises:
+            MuxUnexpectedException: when called before finishing the previous
+                write.
+        """
+
+        try:
+            self._write_condition.acquire()
+            if self._waiting_write_completion:
+                raise MuxUnexpectedException(
+                    'Logical connection %d is already waiting the completion '
+                    'of write' % self._channel_id)
+
+            self._waiting_write_completion = True
+            self._mux_handler.send_data(self._channel_id, data)
+            self._write_condition.wait()
+        finally:
+            self._write_condition.release()
+
+    def write_control_data(self, data):
+        """Writes data via the control channel. Don't wait finishing write
+        because this method can be called by mux dispatcher.
+
+        Args:
+            data: data to be written.
+        """
+
+        self._mux_handler.send_control_data(data)
+
+    def notify_write_done(self):
+        """Called when sending data is completed."""
+
+        try:
+            self._write_condition.acquire()
+            if not self._waiting_write_completion:
+                raise MuxUnexpectedException(
+                    'Invalid call of notify_write_done for logical connection'
+                    ' %d' % self._channel_id)
+            self._waiting_write_completion = False
+            self._write_condition.notify()
+        finally:
+            self._write_condition.release()
+
+    def append_frame_data(self, frame_data):
+        """Appends incoming frame data. Called when mux_handler dispatches
+        frame data to the corresponding application.
+
+        Args:
+            frame_data: incoming frame data.
+        """
+
+        self._read_condition.acquire()
+        self._incoming_data += frame_data
+        self._read_condition.notify()
+        self._read_condition.release()
+
+    def read(self, length):
+        """Reads data. Blocks until enough data has arrived via physical
+        connection.
+
+        Args:
+            length: length of data to be read.
+        Raises:
+            LogicalConnectionClosedException: when closing handshake for this
+                logical channel has been received.
+            ConnectionTerminatedException: when the physical connection has
+                closed, or an error is caused on the reader thread.
+        """
+
+        self._read_condition.acquire()
+        while (self._read_state == self.STATE_ACTIVE and
+               len(self._incoming_data) < length):
+            self._read_condition.wait()
+
+        try:
+            if self._read_state == self.STATE_GRACEFULLY_CLOSED:
+                raise LogicalConnectionClosedException(
+                    'Logical channel %d has closed.' % self._channel_id)
+            elif self._read_state == self.STATE_TERMINATED:
+                raise ConnectionTerminatedException(
+                    'Receiving %d byte failed. Logical channel (%d) closed' %
+                    (length, self._channel_id))
+
+            value = self._incoming_data[:length]
+            self._incoming_data = self._incoming_data[length:]
+        finally:
+            self._read_condition.release()
+
+        return value
+
+    def set_read_state(self, new_state):
+        """Sets the state of this connection. Called when an event for this
+        connection has occurred.
+
+        Args:
+            new_state: state to be set. new_state must be one of followings:
+            - STATE_GRACEFULLY_CLOSED: when closing handshake for this
+                connection has been received.
+            - STATE_TERMINATED: when the physical connection has closed or
+                DropChannel of this connection has received.
+        """
+
+        self._read_condition.acquire()
+        self._read_state = new_state
+        self._read_condition.notify()
+        self._read_condition.release()
+
+
+class _LogicalStream(Stream):
+    """Mimics the Stream class. This class interprets multiplexed WebSocket
+    frames.
+    """
+
+    def __init__(self, request, send_quota, receive_quota):
+        """Constructs an instance.
+
+        Args:
+            request: _LogicalRequest instance.
+            send_quota: Initial send quota.
+            receive_quota: Initial receive quota.
+        """
+
+        # TODO(bashi): Support frame filters.
+        stream_options = StreamOptions()
+        # Physical stream is responsible for masking.
+        stream_options.unmask_receive = False
+        # Control frames can be fragmented on logical channel.
+        stream_options.allow_fragmented_control_frame = True
+        Stream.__init__(self, request, stream_options)
+        self._send_quota = send_quota
+        self._send_quota_condition = threading.Condition()
+        self._receive_quota = receive_quota
+        self._write_inner_frame_semaphore = threading.Semaphore()
+
+    def _create_inner_frame(self, opcode, payload, end=True):
+        # TODO(bashi): Support extensions that use reserved bits.
+        first_byte = (end << 7) | opcode
+        return (_encode_channel_id(self._request.channel_id) +
+                chr(first_byte) + payload)
+
+    def _write_inner_frame(self, opcode, payload, end=True):
+        payload_length = len(payload)
+        write_position = 0
+
+        try:
+            # An inner frame will be fragmented if there is no enough send
+            # quota. This semaphore ensures that fragmented inner frames are
+            # sent in order on the logical channel.
+            # Note that frames that come from other logical channels or
+            # multiplexing control blocks can be inserted between fragmented
+            # inner frames on the physical channel.
+            self._write_inner_frame_semaphore.acquire()
+            while write_position < payload_length:
+                try:
+                    self._send_quota_condition.acquire()
+                    while self._send_quota == 0:
+                        self._logger.debug(
+                            'No quota. Waiting FlowControl message for %d.' %
+                            self._request.channel_id)
+                        self._send_quota_condition.wait()
+
+                    remaining = payload_length - write_position
+                    write_length = min(self._send_quota, remaining)
+                    inner_frame_end = (
+                        end and
+                        (write_position + write_length == payload_length))
+
+                    inner_frame = self._create_inner_frame(
+                        opcode,
+                        payload[write_position:write_position+write_length],
+                        inner_frame_end)
+                    frame_data = self._writer.build(
+                        inner_frame, end=True, binary=True)
+                    self._send_quota -= write_length
+                    self._logger.debug('Consumed quota=%d, remaining=%d' %
+                                       (write_length, self._send_quota))
+                finally:
+                    self._send_quota_condition.release()
+
+                # Writing data will block the worker so we need to release
+                # _send_quota_condition before writing.
+                self._logger.debug('Sending inner frame: %r' % frame_data)
+                self._request.connection.write(frame_data)
+                write_position += write_length
+
+                opcode = common.OPCODE_CONTINUATION
+
+        except ValueError, e:
+            raise BadOperationException(e)
+        finally:
+            self._write_inner_frame_semaphore.release()
+
+    def replenish_send_quota(self, send_quota):
+        """Replenish send quota."""
+
+        self._send_quota_condition.acquire()
+        self._send_quota += send_quota
+        self._logger.debug('Replenished send quota for channel id %d: %d' %
+                           (self._request.channel_id, self._send_quota))
+        self._send_quota_condition.notify()
+        self._send_quota_condition.release()
+
+    def consume_receive_quota(self, amount):
+        """Consumes receive quota. Returns False on failure."""
+
+        if self._receive_quota < amount:
+            self._logger.debug('Violate quota on channel id %d: %d < %d' %
+                               (self._request.channel_id,
+                                self._receive_quota, amount))
+            return False
+        self._receive_quota -= amount
+        return True
+
+    def send_message(self, message, end=True, binary=False):
+        """Override Stream.send_message."""
+
+        if self._request.server_terminated:
+            raise BadOperationException(
+                'Requested send_message after sending out a closing handshake')
+
+        if binary and isinstance(message, unicode):
+            raise BadOperationException(
+                'Message for binary frame must be instance of str')
+
+        if binary:
+            opcode = common.OPCODE_BINARY
+        else:
+            opcode = common.OPCODE_TEXT
+            message = message.encode('utf-8')
+
+        self._write_inner_frame(opcode, message, end)
+
+    def _receive_frame(self):
+        """Overrides Stream._receive_frame.
+
+        In addition to call Stream._receive_frame, this method adds the amount
+        of payload to receiving quota and sends FlowControl to the client.
+        We need to do it here because Stream.receive_message() handles
+        control frames internally.
+        """
+
+        opcode, payload, fin, rsv1, rsv2, rsv3 = Stream._receive_frame(self)
+        amount = len(payload)
+        self._receive_quota += amount
+        frame_data = _create_flow_control(self._request.channel_id,
+                                          amount)
+        self._logger.debug('Sending flow control for %d, replenished=%d' %
+                           (self._request.channel_id, amount))
+        self._request.connection.write_control_data(frame_data)
+        return opcode, payload, fin, rsv1, rsv2, rsv3
+
+    def receive_message(self):
+        """Overrides Stream.receive_message."""
+
+        # Just call Stream.receive_message(), but catch
+        # LogicalConnectionClosedException, which is raised when the logical
+        # connection has closed gracefully.
+        try:
+            return Stream.receive_message(self)
+        except LogicalConnectionClosedException, e:
+            self._logger.debug('%s', e)
+            return None
+
+    def _send_closing_handshake(self, code, reason):
+        """Overrides Stream._send_closing_handshake."""
+
+        body = create_closing_handshake_body(code, reason)
+        self._logger.debug('Sending closing handshake for %d: (%r, %r)' %
+                           (self._request.channel_id, code, reason))
+        self._write_inner_frame(common.OPCODE_CLOSE, body, end=True)
+
+        self._request.server_terminated = True
+
+    def send_ping(self, body=''):
+        """Overrides Stream.send_ping"""
+
+        self._logger.debug('Sending ping on logical channel %d: %r' %
+                           (self._request.channel_id, body))
+        self._write_inner_frame(common.OPCODE_PING, body, end=True)
+
+        self._ping_queue.append(body)
+
+    def _send_pong(self, body):
+        """Overrides Stream._send_pong"""
+
+        self._logger.debug('Sending pong on logical channel %d: %r' %
+                           (self._request.channel_id, body))
+        self._write_inner_frame(common.OPCODE_PONG, body, end=True)
+
+    def close_connection(self, code=common.STATUS_NORMAL_CLOSURE, reason=''):
+        """Overrides Stream.close_connection."""
+
+        # TODO(bashi): Implement
+        self._logger.debug('Closing logical connection %d' %
+                           self._request.channel_id)
+        self._request.server_terminated = True
+
+    def _drain_received_data(self):
+        """Overrides Stream._drain_received_data. Nothing need to be done for
+        logical channel.
+        """
+
+        pass
+
+
+class _OutgoingData(object):
+    """A structure that holds data to be sent via physical connection and
+    origin of the data.
+    """
+
+    def __init__(self, channel_id, data):
+        self.channel_id = channel_id
+        self.data = data
+
+
+class _PhysicalConnectionWriter(threading.Thread):
+    """A thread that is responsible for writing data to physical connection.
+
+    TODO(bashi): Make sure there is no thread-safety problem when the reader
+    thread reads data from the same socket at a time.
+    """
+
+    def __init__(self, mux_handler):
+        """Constructs an instance.
+
+        Args:
+            mux_handler: _MuxHandler instance.
+        """
+
+        threading.Thread.__init__(self)
+        self._logger = util.get_class_logger(self)
+        self._mux_handler = mux_handler
+        self.setDaemon(True)
+        self._stop_requested = False
+        self._deque = collections.deque()
+        self._deque_condition = threading.Condition()
+
+    def put_outgoing_data(self, data):
+        """Puts outgoing data.
+
+        Args:
+            data: _OutgoingData instance.
+
+        Raises:
+            BadOperationException: when the thread has been requested to
+                terminate.
+        """
+
+        try:
+            self._deque_condition.acquire()
+            if self._stop_requested:
+                raise BadOperationException('Cannot write data anymore')
+
+            self._deque.append(data)
+            self._deque_condition.notify()
+        finally:
+            self._deque_condition.release()
+
+    def _write_data(self, outgoing_data):
+        try:
+            self._mux_handler.physical_connection.write(outgoing_data.data)
+        except Exception, e:
+            util.prepend_message_to_exception(
+                'Failed to send message to %r: ' %
+                (self._mux_handler.physical_connection.remote_addr,), e)
+            raise
+
+        # TODO(bashi): It would be better to block the thread that sends
+        # control data as well.
+        if outgoing_data.channel_id != _CONTROL_CHANNEL_ID:
+            self._mux_handler.notify_write_done(outgoing_data.channel_id)
+
+    def run(self):
+        self._deque_condition.acquire()
+        while not self._stop_requested:
+            if len(self._deque) == 0:
+                self._deque_condition.wait()
+                continue
+
+            outgoing_data = self._deque.popleft()
+            self._deque_condition.release()
+            self._write_data(outgoing_data)
+            self._deque_condition.acquire()
+
+        # Flush deque
+        try:
+            while len(self._deque) > 0:
+                outgoing_data = self._deque.popleft()
+                self._write_data(outgoing_data)
+        finally:
+            self._deque_condition.release()
+
+    def stop(self):
+        """Stops the writer thread."""
+
+        self._deque_condition.acquire()
+        self._stop_requested = True
+        self._deque_condition.notify()
+        self._deque_condition.release()
+
+
+class _PhysicalConnectionReader(threading.Thread):
+    """A thread that is responsible for reading data from physical connection.
+    """
+
+    def __init__(self, mux_handler):
+        """Constructs an instance.
+
+        Args:
+            mux_handler: _MuxHandler instance.
+        """
+
+        threading.Thread.__init__(self)
+        self._logger = util.get_class_logger(self)
+        self._mux_handler = mux_handler
+        self.setDaemon(True)
+
+    def run(self):
+        while True:
+            try:
+                physical_stream = self._mux_handler.physical_stream
+                message = physical_stream.receive_message()
+                if message is None:
+                    break
+                # Below happens only when a data message is received.
+                opcode = physical_stream.get_last_received_opcode()
+                if opcode != common.OPCODE_BINARY:
+                    self._mux_handler.fail_physical_connection(
+                        _DROP_CODE_INVALID_ENCAPSULATING_MESSAGE,
+                        'Received a text message on physical connection')
+                    break
+
+            except ConnectionTerminatedException, e:
+                self._logger.debug('%s', e)
+                break
+
+            try:
+                self._mux_handler.dispatch_message(message)
+            except PhysicalConnectionError, e:
+                self._mux_handler.fail_physical_connection(
+                    e.drop_code, e.message)
+                break
+            except LogicalChannelError, e:
+                self._mux_handler.fail_logical_channel(
+                    e.channel_id, e.drop_code, e.message)
+            except Exception, e:
+                self._logger.debug(traceback.format_exc())
+                break
+
+        self._mux_handler.notify_reader_done()
+
+
+class _Worker(threading.Thread):
+    """A thread that is responsible for running the corresponding application
+    handler.
+    """
+
+    def __init__(self, mux_handler, request):
+        """Constructs an instance.
+
+        Args:
+            mux_handler: _MuxHandler instance.
+            request: _LogicalRequest instance.
+        """
+
+        threading.Thread.__init__(self)
+        self._logger = util.get_class_logger(self)
+        self._mux_handler = mux_handler
+        self._request = request
+        self.setDaemon(True)
+
+    def run(self):
+        self._logger.debug('Logical channel worker started. (id=%d)' %
+                           self._request.channel_id)
+        try:
+            # Non-critical exceptions will be handled by dispatcher.
+            self._mux_handler.dispatcher.transfer_data(self._request)
+        finally:
+            self._mux_handler.notify_worker_done(self._request.channel_id)
+
+
+class _MuxHandshaker(hybi.Handshaker):
+    """Opening handshake processor for multiplexing."""
+
+    _DUMMY_WEBSOCKET_KEY = 'dGhlIHNhbXBsZSBub25jZQ=='
+
+    def __init__(self, request, dispatcher, send_quota, receive_quota):
+        """Constructs an instance.
+        Args:
+            request: _LogicalRequest instance.
+            dispatcher: Dispatcher instance (dispatch.Dispatcher).
+            send_quota: Initial send quota.
+            receive_quota: Initial receive quota.
+        """
+
+        hybi.Handshaker.__init__(self, request, dispatcher)
+        self._send_quota = send_quota
+        self._receive_quota = receive_quota
+
+        # Append headers which should not be included in handshake field of
+        # AddChannelRequest.
+        # TODO(bashi): Make sure whether we should raise exception when
+        #     these headers are included already.
+        request.headers_in[common.UPGRADE_HEADER] = (
+            common.WEBSOCKET_UPGRADE_TYPE)
+        request.headers_in[common.CONNECTION_HEADER] = (
+            common.UPGRADE_CONNECTION_TYPE)
+        request.headers_in[common.SEC_WEBSOCKET_VERSION_HEADER] = (
+            str(common.VERSION_HYBI_LATEST))
+        request.headers_in[common.SEC_WEBSOCKET_KEY_HEADER] = (
+            self._DUMMY_WEBSOCKET_KEY)
+
+    def _create_stream(self, stream_options):
+        """Override hybi.Handshaker._create_stream."""
+
+        self._logger.debug('Creating logical stream for %d' %
+                           self._request.channel_id)
+        return _LogicalStream(self._request, self._send_quota,
+                              self._receive_quota)
+
+    def _create_handshake_response(self, accept):
+        """Override hybi._create_handshake_response."""
+
+        response = []
+
+        response.append('HTTP/1.1 101 Switching Protocols\r\n')
+
+        # Upgrade, Connection and Sec-WebSocket-Accept should be excluded.
+        if self._request.ws_protocol is not None:
+            response.append('%s: %s\r\n' % (
+                common.SEC_WEBSOCKET_PROTOCOL_HEADER,
+                self._request.ws_protocol))
+        if (self._request.ws_extensions is not None and
+            len(self._request.ws_extensions) != 0):
+            response.append('%s: %s\r\n' % (
+                common.SEC_WEBSOCKET_EXTENSIONS_HEADER,
+                common.format_extensions(self._request.ws_extensions)))
+        response.append('\r\n')
+
+        return ''.join(response)
+
+    def _send_handshake(self, accept):
+        """Override hybi.Handshaker._send_handshake."""
+
+        # Don't send handshake response for the default channel
+        if self._request.channel_id == _DEFAULT_CHANNEL_ID:
+            return
+
+        handshake_response = self._create_handshake_response(accept)
+        frame_data = _create_add_channel_response(
+                         self._request.channel_id,
+                         handshake_response)
+        self._logger.debug('Sending handshake response for %d: %r' %
+                           (self._request.channel_id, frame_data))
+        self._request.connection.write_control_data(frame_data)
+
+
+class _LogicalChannelData(object):
+    """A structure that holds information about logical channel.
+    """
+
+    def __init__(self, request, worker):
+        self.request = request
+        self.worker = worker
+        self.drop_code = _DROP_CODE_NORMAL_CLOSURE
+        self.drop_message = ''
+
+
+class _HandshakeDeltaBase(object):
+    """A class that holds information for delta-encoded handshake."""
+
+    def __init__(self, headers):
+        self._headers = headers
+
+    def create_headers(self, delta=None):
+        """Creates request headers for an AddChannelRequest that has
+        delta-encoded handshake.
+
+        Args:
+            delta: headers should be overridden.
+        """
+
+        headers = copy.copy(self._headers)
+        if delta:
+            for key, value in delta.items():
+                # The spec requires that a header with an empty value is
+                # removed from the delta base.
+                if len(value) == 0 and headers.has_key(key):
+                    del headers[key]
+                else:
+                    headers[key] = value
+        # TODO(bashi): Support extensions
+        headers['Sec-WebSocket-Extensions'] = ''
+        return headers
+
+
+class _MuxHandler(object):
+    """Multiplexing handler. When a handler starts, it launches three
+    threads; the reader thread, the writer thread, and a worker thread.
+
+    The reader thread reads data from the physical stream, i.e., the
+    ws_stream object of the underlying websocket connection. The reader
+    thread interprets multiplexed frames and dispatches them to logical
+    channels. Methods of this class are mostly called by the reader thread.
+
+    The writer thread sends multiplexed frames which are created by
+    logical channels via the physical connection.
+
+    The worker thread launched at the starting point handles the
+    "Implicitly Opened Connection". If multiplexing handler receives
+    an AddChannelRequest and accepts it, the handler will launch a new worker
+    thread and dispatch the request to it.
+    """
+
+    def __init__(self, request, dispatcher):
+        """Constructs an instance.
+
+        Args:
+            request: mod_python request of the physical connection.
+            dispatcher: Dispatcher instance (dispatch.Dispatcher).
+        """
+
+        self.original_request = request
+        self.dispatcher = dispatcher
+        self.physical_connection = request.connection
+        self.physical_stream = request.ws_stream
+        self._logger = util.get_class_logger(self)
+        self._logical_channels = {}
+        self._logical_channels_condition = threading.Condition()
+        # Holds client's initial quota
+        self._channel_slots = collections.deque()
+        self._handshake_base = None
+        self._worker_done_notify_received = False
+        self._reader = None
+        self._writer = None
+
+    def start(self):
+        """Starts the handler.
+
+        Raises:
+            MuxUnexpectedException: when the handler already started, or when
+                opening handshake of the default channel fails.
+        """
+
+        if self._reader or self._writer:
+            raise MuxUnexpectedException('MuxHandler already started')
+
+        self._reader = _PhysicalConnectionReader(self)
+        self._writer = _PhysicalConnectionWriter(self)
+        self._reader.start()
+        self._writer.start()
+
+        # Create "Implicitly Opened Connection".
+        logical_connection = _LogicalConnection(self, _DEFAULT_CHANNEL_ID)
+        self._handshake_base = _HandshakeDeltaBase(
+            self.original_request.headers_in)
+        logical_request = _LogicalRequest(
+            _DEFAULT_CHANNEL_ID,
+            self.original_request.method,
+            self.original_request.uri,
+            self.original_request.protocol,
+            self._handshake_base.create_headers(),
+            logical_connection)
+        # Client's send quota for the implicitly opened connection is zero,
+        # but we will send FlowControl later so set the initial quota to
+        # _INITIAL_QUOTA_FOR_CLIENT.
+        self._channel_slots.append(_INITIAL_QUOTA_FOR_CLIENT)
+        if not self._do_handshake_for_logical_request(
+            logical_request, send_quota=self.original_request.mux_quota):
+            raise MuxUnexpectedException(
+                'Failed handshake on the default channel id')
+        self._add_logical_channel(logical_request)
+
+        # Send FlowControl for the implicitly opened connection.
+        frame_data = _create_flow_control(_DEFAULT_CHANNEL_ID,
+                                          _INITIAL_QUOTA_FOR_CLIENT)
+        logical_request.connection.write_control_data(frame_data)
+
+    def add_channel_slots(self, slots, send_quota):
+        """Adds channel slots.
+
+        Args:
+            slots: number of slots to be added.
+            send_quota: initial send quota for slots.
+        """
+
+        self._channel_slots.extend([send_quota] * slots)
+        # Send NewChannelSlot to client.
+        frame_data = _create_new_channel_slot(slots, send_quota)
+        self.send_control_data(frame_data)
+
+    def wait_until_done(self, timeout=None):
+        """Waits until all workers are done. Returns False when timeout has
+        occurred. Returns True on success.
+
+        Args:
+            timeout: timeout in sec.
+        """
+
+        self._logical_channels_condition.acquire()
+        try:
+            while len(self._logical_channels) > 0:
+                self._logger.debug('Waiting workers(%d)...' %
+                                   len(self._logical_channels))
+                self._worker_done_notify_received = False
+                self._logical_channels_condition.wait(timeout)
+                if not self._worker_done_notify_received:
+                    self._logger.debug('Waiting worker(s) timed out')
+                    return False
+
+        finally:
+            self._logical_channels_condition.release()
+
+        # Flush pending outgoing data
+        self._writer.stop()
+        self._writer.join()
+
+        return True
+
+    def notify_write_done(self, channel_id):
+        """Called by the writer thread when a write operation has done.
+
+        Args:
+            channel_id: objective channel id.
+        """
+
+        try:
+            self._logical_channels_condition.acquire()
+            if channel_id in self._logical_channels:
+                channel_data = self._logical_channels[channel_id]
+                channel_data.request.connection.notify_write_done()
+            else:
+                self._logger.debug('Seems that logical channel for %d has gone'
+                                   % channel_id)
+        finally:
+            self._logical_channels_condition.release()
+
+    def send_control_data(self, data):
+        """Sends data via the control channel.
+
+        Args:
+            data: data to be sent.
+        """
+
+        self._writer.put_outgoing_data(_OutgoingData(
+                channel_id=_CONTROL_CHANNEL_ID, data=data))
+
+    def send_data(self, channel_id, data):
+        """Sends data via given logical channel. This method is called by
+        worker threads.
+
+        Args:
+            channel_id: objective channel id.
+            data: data to be sent.
+        """
+
+        self._writer.put_outgoing_data(_OutgoingData(
+                channel_id=channel_id, data=data))
+
+    def _send_drop_channel(self, channel_id, code=None, message=''):
+        frame_data = _create_drop_channel(channel_id, code, message)
+        self._logger.debug(
+            'Sending drop channel for channel id %d' % channel_id)
+        self.send_control_data(frame_data)
+
+    def _send_error_add_channel_response(self, channel_id, status=None):
+        if status is None:
+            status = common.HTTP_STATUS_BAD_REQUEST
+
+        if status in _HTTP_BAD_RESPONSE_MESSAGES:
+            message = _HTTP_BAD_RESPONSE_MESSAGES[status]
+        else:
+            self._logger.debug('Response message for %d is not found' % status)
+            message = '???'
+
+        response = 'HTTP/1.1 %d %s\r\n\r\n' % (status, message)
+        frame_data = _create_add_channel_response(channel_id,
+                                                  encoded_handshake=response,
+                                                  encoding=0, rejected=True)
+        self.send_control_data(frame_data)
+
+    def _create_logical_request(self, block):
+        if block.channel_id == _CONTROL_CHANNEL_ID:
+            # TODO(bashi): Raise PhysicalConnectionError with code 2006
+            # instead of MuxUnexpectedException.
+            raise MuxUnexpectedException(
+                'Received the control channel id (0) as objective channel '
+                'id for AddChannel')
+
+        if block.encoding > _HANDSHAKE_ENCODING_DELTA:
+            raise PhysicalConnectionError(
+                _DROP_CODE_UNKNOWN_REQUEST_ENCODING)
+
+        method, path, version, headers = _parse_request_text(
+            block.encoded_handshake)
+        if block.encoding == _HANDSHAKE_ENCODING_DELTA:
+            headers = self._handshake_base.create_headers(headers)
+
+        connection = _LogicalConnection(self, block.channel_id)
+        request = _LogicalRequest(block.channel_id, method, path, version,
+                                  headers, connection)
+        return request
+
+    def _do_handshake_for_logical_request(self, request, send_quota=0):
+        try:
+            receive_quota = self._channel_slots.popleft()
+        except IndexError:
+            raise LogicalChannelError(
+                request.channel_id, _DROP_CODE_NEW_CHANNEL_SLOT_VIOLATION)
+
+        handshaker = _MuxHandshaker(request, self.dispatcher,
+                                    send_quota, receive_quota)
+        try:
+            handshaker.do_handshake()
+        except handshake.VersionException, e:
+            self._logger.info('%s', e)
+            self._send_error_add_channel_response(
+                request.channel_id, status=common.HTTP_STATUS_BAD_REQUEST)
+            return False
+        except handshake.HandshakeException, e:
+            # TODO(bashi): Should we _Fail the Logical Channel_ with 3001
+            # instead?
+            self._logger.info('%s', e)
+            self._send_error_add_channel_response(request.channel_id,
+                                                  status=e.status)
+            return False
+        except handshake.AbortedByUserException, e:
+            self._logger.info('%s', e)
+            self._send_error_add_channel_response(request.channel_id)
+            return False
+
+        return True
+
+    def _add_logical_channel(self, logical_request):
+        try:
+            self._logical_channels_condition.acquire()
+            if logical_request.channel_id in self._logical_channels:
+                self._logger.debug('Channel id %d already exists' %
+                                   logical_request.channel_id)
+                raise PhysicalConnectionError(
+                    _DROP_CODE_CHANNEL_ALREADY_EXISTS,
+                    'Channel id %d already exists' %
+                    logical_request.channel_id)
+            worker = _Worker(self, logical_request)
+            channel_data = _LogicalChannelData(logical_request, worker)
+            self._logical_channels[logical_request.channel_id] = channel_data
+            worker.start()
+        finally:
+            self._logical_channels_condition.release()
+
+    def _process_add_channel_request(self, block):
+        try:
+            logical_request = self._create_logical_request(block)
+        except ValueError, e:
+            self._logger.debug('Failed to create logical request: %r' % e)
+            self._send_error_add_channel_response(
+                block.channel_id, status=common.HTTP_STATUS_BAD_REQUEST)
+            return
+        if self._do_handshake_for_logical_request(logical_request):
+            if block.encoding == _HANDSHAKE_ENCODING_IDENTITY:
+                # Update handshake base.
+                # TODO(bashi): Make sure this is the right place to update
+                # handshake base.
+                self._handshake_base = _HandshakeDeltaBase(
+                    logical_request.headers_in)
+            self._add_logical_channel(logical_request)
+        else:
+            self._send_error_add_channel_response(
+                block.channel_id, status=common.HTTP_STATUS_BAD_REQUEST)
+
+    def _process_flow_control(self, block):
+        try:
+            self._logical_channels_condition.acquire()
+            if not block.channel_id in self._logical_channels:
+                return
+            channel_data = self._logical_channels[block.channel_id]
+            channel_data.request.ws_stream.replenish_send_quota(
+                block.send_quota)
+        finally:
+            self._logical_channels_condition.release()
+
+    def _process_drop_channel(self, block):
+        self._logger.debug(
+            'DropChannel received for %d: code=%r, reason=%r' %
+            (block.channel_id, block.drop_code, block.drop_message))
+        try:
+            self._logical_channels_condition.acquire()
+            if not block.channel_id in self._logical_channels:
+                return
+            channel_data = self._logical_channels[block.channel_id]
+            channel_data.drop_code = _DROP_CODE_ACKNOWLEDGED
+            # Close the logical channel
+            channel_data.request.connection.set_read_state(
+                _LogicalConnection.STATE_TERMINATED)
+        finally:
+            self._logical_channels_condition.release()
+
+    def _process_control_blocks(self, parser):
+        for control_block in parser.read_control_blocks():
+            opcode = control_block.opcode
+            self._logger.debug('control block received, opcode: %d' % opcode)
+            if opcode == _MUX_OPCODE_ADD_CHANNEL_REQUEST:
+                self._process_add_channel_request(control_block)
+            elif opcode == _MUX_OPCODE_ADD_CHANNEL_RESPONSE:
+                raise PhysicalConnectionError(
+                    _DROP_CODE_INVALID_MUX_CONTROL_BLOCK,
+                    'Received AddChannelResponse')
+            elif opcode == _MUX_OPCODE_FLOW_CONTROL:
+                self._process_flow_control(control_block)
+            elif opcode == _MUX_OPCODE_DROP_CHANNEL:
+                self._process_drop_channel(control_block)
+            elif opcode == _MUX_OPCODE_NEW_CHANNEL_SLOT:
+                raise PhysicalConnectionError(
+                    _DROP_CODE_INVALID_MUX_CONTROL_BLOCK,
+                    'Received NewChannelSlot')
+            else:
+                raise MuxUnexpectedException(
+                    'Unexpected opcode %r' % opcode)
+
+    def _process_logical_frame(self, channel_id, parser):
+        self._logger.debug('Received a frame. channel id=%d' % channel_id)
+        try:
+            self._logical_channels_condition.acquire()
+            if not channel_id in self._logical_channels:
+                # We must ignore the message for an inactive channel.
+                return
+            channel_data = self._logical_channels[channel_id]
+            fin, rsv1, rsv2, rsv3, opcode, payload = parser.read_inner_frame()
+            if not channel_data.request.ws_stream.consume_receive_quota(
+                len(payload)):
+                # The client violates quota. Close logical channel.
+                raise LogicalChannelError(
+                    channel_id, _DROP_CODE_SEND_QUOTA_VIOLATION)
+            header = create_header(opcode, len(payload), fin, rsv1, rsv2, rsv3,
+                                   mask=False)
+            frame_data = header + payload
+            channel_data.request.connection.append_frame_data(frame_data)
+        finally:
+            self._logical_channels_condition.release()
+
+    def dispatch_message(self, message):
+        """Dispatches message. The reader thread calls this method.
+
+        Args:
+            message: a message that contains encapsulated frame.
+        Raises:
+            PhysicalConnectionError: if the message contains physical
+                connection level errors.
+            LogicalChannelError: if the message contains logical channel
+                level errors.
+        """
+
+        parser = _MuxFramePayloadParser(message)
+        try:
+            channel_id = parser.read_channel_id()
+        except ValueError, e:
+            raise PhysicalConnectionError(_DROP_CODE_CHANNEL_ID_TRUNCATED)
+        if channel_id == _CONTROL_CHANNEL_ID:
+            self._process_control_blocks(parser)
+        else:
+            self._process_logical_frame(channel_id, parser)
+
+    def notify_worker_done(self, channel_id):
+        """Called when a worker has finished.
+
+        Args:
+            channel_id: channel id corresponded with the worker.
+        """
+
+        self._logger.debug('Worker for channel id %d terminated' % channel_id)
+        try:
+            self._logical_channels_condition.acquire()
+            if not channel_id in self._logical_channels:
+                raise MuxUnexpectedException(
+                    'Channel id %d not found' % channel_id)
+            channel_data = self._logical_channels.pop(channel_id)
+        finally:
+            self._worker_done_notify_received = True
+            self._logical_channels_condition.notify()
+            self._logical_channels_condition.release()
+
+        if not channel_data.request.server_terminated:
+            self._send_drop_channel(
+                channel_id, code=channel_data.drop_code,
+                message=channel_data.drop_message)
+
+    def notify_reader_done(self):
+        """This method is called by the reader thread when the reader has
+        finished.
+        """
+
+        # Terminate all logical connections
+        self._logger.debug('termiating all logical connections...')
+        self._logical_channels_condition.acquire()
+        for channel_data in self._logical_channels.values():
+            try:
+                channel_data.request.connection.set_read_state(
+                    _LogicalConnection.STATE_TERMINATED)
+            except Exception:
+                pass
+        self._logical_channels_condition.release()
+
+    def fail_physical_connection(self, code, message):
+        """Fail the physical connection.
+
+        Args:
+            code: drop reason code.
+            message: drop message.
+        """
+
+        self._logger.debug('Failing the physical connection...')
+        self._send_drop_channel(_CONTROL_CHANNEL_ID, code, message)
+        self.physical_stream.close_connection(
+            common.STATUS_INTERNAL_ENDPOINT_ERROR)
+
+    def fail_logical_channel(self, channel_id, code, message):
+        """Fail a logical channel.
+
+        Args:
+            channel_id: channel id.
+            code: drop reason code.
+            message: drop message.
+        """
+
+        self._logger.debug('Failing logical channel %d...' % channel_id)
+        try:
+            self._logical_channels_condition.acquire()
+            if channel_id in self._logical_channels:
+                channel_data = self._logical_channels[channel_id]
+                # Close the logical channel. notify_worker_done() will be
+                # called later and it will send DropChannel.
+                channel_data.drop_code = code
+                channel_data.drop_message = message
+                channel_data.request.connection.set_read_state(
+                    _LogicalConnection.STATE_TERMINATED)
+            else:
+                self._send_drop_channel(channel_id, code, message)
+        finally:
+            self._logical_channels_condition.release()
+
+
+def use_mux(request):
+    return hasattr(request, 'mux') and request.mux
+
+
+def start(request, dispatcher):
+    mux_handler = _MuxHandler(request, dispatcher)
+    mux_handler.start()
+
+    mux_handler.add_channel_slots(_INITIAL_NUMBER_OF_CHANNEL_SLOTS,
+                                  _INITIAL_QUOTA_FOR_CLIENT)
+
+    mux_handler.wait_until_done()
+
+
+# vi:sts=4 sw=4 et
diff --git a/module/lib/mod_pywebsocket/standalone.py b/module/lib/mod_pywebsocket/standalone.py
new file mode 100755
index 000000000..07a33d9c9
--- /dev/null
+++ b/module/lib/mod_pywebsocket/standalone.py
@@ -0,0 +1,998 @@
+#!/usr/bin/env python
+#
+# Copyright 2012, Google Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+"""Standalone WebSocket server.
+
+Use this file to launch pywebsocket without Apache HTTP Server.
+
+
+BASIC USAGE
+
+Go to the src directory and run
+
+  $ python mod_pywebsocket/standalone.py [-p <ws_port>]
+                                         [-w <websock_handlers>]
+                                         [-d <document_root>]
+
+<ws_port> is the port number to use for ws:// connection.
+
+<document_root> is the path to the root directory of HTML files.
+
+<websock_handlers> is the path to the root directory of WebSocket handlers.
+If not specified, <document_root> will be used. See __init__.py (or
+run $ pydoc mod_pywebsocket) for how to write WebSocket handlers.
+
+For more detail and other options, run
+
+  $ python mod_pywebsocket/standalone.py --help
+
+or see _build_option_parser method below.
+
+For trouble shooting, adding "--log_level debug" might help you.
+
+
+TRY DEMO
+
+Go to the src directory and run
+
+  $ python standalone.py -d example
+
+to launch pywebsocket with the sample handler and html on port 80. Open
+http://localhost/console.html, click the connect button, type something into
+the text box next to the send button and click the send button. If everything
+is working, you'll see the message you typed echoed by the server.
+
+
+SUPPORTING TLS
+
+To support TLS, run standalone.py with -t, -k, and -c options.
+
+
+SUPPORTING CLIENT AUTHENTICATION
+
+To support client authentication with TLS, run standalone.py with -t, -k, -c,
+and --tls-client-auth, and --tls-client-ca options.
+
+E.g., $./standalone.py -d ../example -p 10443 -t -c ../test/cert/cert.pem -k
+../test/cert/key.pem --tls-client-auth --tls-client-ca=../test/cert/cacert.pem
+
+
+CONFIGURATION FILE
+
+You can also write a configuration file and use it by specifying the path to
+the configuration file by --config option. Please write a configuration file
+following the documentation of the Python ConfigParser library. Name of each
+entry must be the long version argument name. E.g. to set log level to debug,
+add the following line:
+
+log_level=debug
+
+For options which doesn't take value, please add some fake value. E.g. for
+--tls option, add the following line:
+
+tls=True
+
+Note that tls will be enabled even if you write tls=False as the value part is
+fake.
+
+When both a command line argument and a configuration file entry are set for
+the same configuration item, the command line value will override one in the
+configuration file.
+
+
+THREADING
+
+This server is derived from SocketServer.ThreadingMixIn. Hence a thread is
+used for each request.
+
+
+SECURITY WARNING
+
+This uses CGIHTTPServer and CGIHTTPServer is not secure.
+It may execute arbitrary Python code or external programs. It should not be
+used outside a firewall.
+"""
+
+import BaseHTTPServer
+import CGIHTTPServer
+import SimpleHTTPServer
+import SocketServer
+import ConfigParser
+import base64
+import httplib
+import logging
+import logging.handlers
+import optparse
+import os
+import re
+import select
+import socket
+import sys
+import threading
+import time
+
+_HAS_SSL = False
+_HAS_OPEN_SSL = False
+try:
+    import ssl
+    _HAS_SSL = True
+except ImportError:
+    try:
+        import OpenSSL.SSL
+        _HAS_OPEN_SSL = True
+    except ImportError:
+        pass
+
+from mod_pywebsocket import common
+from mod_pywebsocket import dispatch
+from mod_pywebsocket import handshake
+from mod_pywebsocket import http_header_util
+from mod_pywebsocket import memorizingfile
+from mod_pywebsocket import util
+
+
+_DEFAULT_LOG_MAX_BYTES = 1024 * 256
+_DEFAULT_LOG_BACKUP_COUNT = 5
+
+_DEFAULT_REQUEST_QUEUE_SIZE = 128
+
+# 1024 is practically large enough to contain WebSocket handshake lines.
+_MAX_MEMORIZED_LINES = 1024
+
+
+class _StandaloneConnection(object):
+    """Mimic mod_python mp_conn."""
+
+    def __init__(self, request_handler):
+        """Construct an instance.
+
+        Args:
+            request_handler: A WebSocketRequestHandler instance.
+        """
+
+        self._request_handler = request_handler
+
+    def get_local_addr(self):
+        """Getter to mimic mp_conn.local_addr."""
+
+        return (self._request_handler.server.server_name,
+                self._request_handler.server.server_port)
+    local_addr = property(get_local_addr)
+
+    def get_remote_addr(self):
+        """Getter to mimic mp_conn.remote_addr.
+
+        Setting the property in __init__ won't work because the request
+        handler is not initialized yet there."""
+
+        return self._request_handler.client_address
+    remote_addr = property(get_remote_addr)
+
+    def write(self, data):
+        """Mimic mp_conn.write()."""
+
+        return self._request_handler.wfile.write(data)
+
+    def read(self, length):
+        """Mimic mp_conn.read()."""
+
+        return self._request_handler.rfile.read(length)
+
+    def get_memorized_lines(self):
+        """Get memorized lines."""
+
+        return self._request_handler.rfile.get_memorized_lines()
+
+
+class _StandaloneRequest(object):
+    """Mimic mod_python request."""
+
+    def __init__(self, request_handler, use_tls):
+        """Construct an instance.
+
+        Args:
+            request_handler: A WebSocketRequestHandler instance.
+        """
+
+        self._logger = util.get_class_logger(self)
+
+        self._request_handler = request_handler
+        self.connection = _StandaloneConnection(request_handler)
+        self._use_tls = use_tls
+        self.headers_in = request_handler.headers
+
+    def get_uri(self):
+        """Getter to mimic request.uri."""
+
+        return self._request_handler.path
+    uri = property(get_uri)
+
+    def get_method(self):
+        """Getter to mimic request.method."""
+
+        return self._request_handler.command
+    method = property(get_method)
+
+    def get_protocol(self):
+        """Getter to mimic request.protocol."""
+
+        return self._request_handler.request_version
+    protocol = property(get_protocol)
+
+    def is_https(self):
+        """Mimic request.is_https()."""
+
+        return self._use_tls
+
+    def _drain_received_data(self):
+        """Don't use this method from WebSocket handler. Drains unread data
+        in the receive buffer.
+        """
+
+        raw_socket = self._request_handler.connection
+        drained_data = util.drain_received_data(raw_socket)
+
+        if drained_data:
+            self._logger.debug(
+                'Drained data following close frame: %r', drained_data)
+
+
+class _StandaloneSSLConnection(object):
+    """A wrapper class for OpenSSL.SSL.Connection to provide makefile method
+    which is not supported by the class.
+    """
+
+    def __init__(self, connection):
+        self._connection = connection
+
+    def __getattribute__(self, name):
+        if name in ('_connection', 'makefile'):
+            return object.__getattribute__(self, name)
+        return self._connection.__getattribute__(name)
+
+    def __setattr__(self, name, value):
+        if name in ('_connection', 'makefile'):
+            return object.__setattr__(self, name, value)
+        return self._connection.__setattr__(name, value)
+
+    def makefile(self, mode='r', bufsize=-1):
+        return socket._fileobject(self._connection, mode, bufsize)
+
+
+def _alias_handlers(dispatcher, websock_handlers_map_file):
+    """Set aliases specified in websock_handler_map_file in dispatcher.
+
+    Args:
+        dispatcher: dispatch.Dispatcher instance
+        websock_handler_map_file: alias map file
+    """
+
+    fp = open(websock_handlers_map_file)
+    try:
+        for line in fp:
+            if line[0] == '#' or line.isspace():
+                continue
+            m = re.match('(\S+)\s+(\S+)', line)
+            if not m:
+                logging.warning('Wrong format in map file:' + line)
+                continue
+            try:
+                dispatcher.add_resource_path_alias(
+                    m.group(1), m.group(2))
+            except dispatch.DispatchException, e:
+                logging.error(str(e))
+    finally:
+        fp.close()
+
+
+class WebSocketServer(SocketServer.ThreadingMixIn, BaseHTTPServer.HTTPServer):
+    """HTTPServer specialized for WebSocket."""
+
+    # Overrides SocketServer.ThreadingMixIn.daemon_threads
+    daemon_threads = True
+    # Overrides BaseHTTPServer.HTTPServer.allow_reuse_address
+    allow_reuse_address = True
+
+    def __init__(self, options):
+        """Override SocketServer.TCPServer.__init__ to set SSL enabled
+        socket object to self.socket before server_bind and server_activate,
+        if necessary.
+        """
+
+        # Share a Dispatcher among request handlers to save time for
+        # instantiation.  Dispatcher can be shared because it is thread-safe.
+        options.dispatcher = dispatch.Dispatcher(
+            options.websock_handlers,
+            options.scan_dir,
+            options.allow_handlers_outside_root_dir)
+        if options.websock_handlers_map_file:
+            _alias_handlers(options.dispatcher,
+                            options.websock_handlers_map_file)
+        warnings = options.dispatcher.source_warnings()
+        if warnings:
+            for warning in warnings:
+                logging.warning('mod_pywebsocket: %s' % warning)
+
+        self._logger = util.get_class_logger(self)
+
+        self.request_queue_size = options.request_queue_size
+        self.__ws_is_shut_down = threading.Event()
+        self.__ws_serving = False
+
+        SocketServer.BaseServer.__init__(
+            self, (options.server_host, options.port), WebSocketRequestHandler)
+
+        # Expose the options object to allow handler objects access it. We name
+        # it with websocket_ prefix to avoid conflict.
+        self.websocket_server_options = options
+
+        self._create_sockets()
+        self.server_bind()
+        self.server_activate()
+
+    def _create_sockets(self):
+        self.server_name, self.server_port = self.server_address
+        self._sockets = []
+        if not self.server_name:
+            # On platforms that doesn't support IPv6, the first bind fails.
+            # On platforms that supports IPv6
+            # - If it binds both IPv4 and IPv6 on call with AF_INET6, the
+            #   first bind succeeds and the second fails (we'll see 'Address
+            #   already in use' error).
+            # - If it binds only IPv6 on call with AF_INET6, both call are
+            #   expected to succeed to listen both protocol.
+            addrinfo_array = [
+                (socket.AF_INET6, socket.SOCK_STREAM, '', '', ''),
+                (socket.AF_INET, socket.SOCK_STREAM, '', '', '')]
+        else:
+            addrinfo_array = socket.getaddrinfo(self.server_name,
+                                                self.server_port,
+                                                socket.AF_UNSPEC,
+                                                socket.SOCK_STREAM,
+                                                socket.IPPROTO_TCP)
+        for addrinfo in addrinfo_array:
+            self._logger.info('Create socket on: %r', addrinfo)
+            family, socktype, proto, canonname, sockaddr = addrinfo
+            try:
+                socket_ = socket.socket(family, socktype)
+            except Exception, e:
+                self._logger.info('Skip by failure: %r', e)
+                continue
+            if self.websocket_server_options.use_tls:
+                if _HAS_SSL:
+                    if self.websocket_server_options.tls_client_auth:
+                        client_cert_ = ssl.CERT_REQUIRED
+                    else:
+                        client_cert_ = ssl.CERT_NONE
+                    socket_ = ssl.wrap_socket(socket_,
+                        keyfile=self.websocket_server_options.private_key,
+                        certfile=self.websocket_server_options.certificate,
+                        ssl_version=ssl.PROTOCOL_SSLv23,
+                        ca_certs=self.websocket_server_options.tls_client_ca,
+                        cert_reqs=client_cert_)
+                if _HAS_OPEN_SSL:
+                    ctx = OpenSSL.SSL.Context(OpenSSL.SSL.SSLv23_METHOD)
+                    ctx.use_privatekey_file(
+                        self.websocket_server_options.private_key)
+                    ctx.use_certificate_file(
+                        self.websocket_server_options.certificate)
+                    socket_ = OpenSSL.SSL.Connection(ctx, socket_)
+            self._sockets.append((socket_, addrinfo))
+
+    def server_bind(self):
+        """Override SocketServer.TCPServer.server_bind to enable multiple
+        sockets bind.
+        """
+
+        failed_sockets = []
+
+        for socketinfo in self._sockets:
+            socket_, addrinfo = socketinfo
+            self._logger.info('Bind on: %r', addrinfo)
+            if self.allow_reuse_address:
+                socket_.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            try:
+                socket_.bind(self.server_address)
+            except Exception, e:
+                self._logger.info('Skip by failure: %r', e)
+                socket_.close()
+                failed_sockets.append(socketinfo)
+            if self.server_address[1] == 0:
+                # The operating system assigns the actual port number for port
+                # number 0. This case, the second and later sockets should use
+                # the same port number. Also self.server_port is rewritten
+                # because it is exported, and will be used by external code.
+                self.server_address = (
+                    self.server_name, socket_.getsockname()[1])
+                self.server_port = self.server_address[1]
+                self._logger.info('Port %r is assigned', self.server_port)
+
+        for socketinfo in failed_sockets:
+            self._sockets.remove(socketinfo)
+
+    def server_activate(self):
+        """Override SocketServer.TCPServer.server_activate to enable multiple
+        sockets listen.
+        """
+
+        failed_sockets = []
+
+        for socketinfo in self._sockets:
+            socket_, addrinfo = socketinfo
+            self._logger.info('Listen on: %r', addrinfo)
+            try:
+                socket_.listen(self.request_queue_size)
+            except Exception, e:
+                self._logger.info('Skip by failure: %r', e)
+                socket_.close()
+                failed_sockets.append(socketinfo)
+
+        for socketinfo in failed_sockets:
+            self._sockets.remove(socketinfo)
+
+        if len(self._sockets) == 0:
+            self._logger.critical(
+                'No sockets activated. Use info log level to see the reason.')
+
+    def server_close(self):
+        """Override SocketServer.TCPServer.server_close to enable multiple
+        sockets close.
+        """
+
+        for socketinfo in self._sockets:
+            socket_, addrinfo = socketinfo
+            self._logger.info('Close on: %r', addrinfo)
+            socket_.close()
+
+    def fileno(self):
+        """Override SocketServer.TCPServer.fileno."""
+
+        self._logger.critical('Not supported: fileno')
+        return self._sockets[0][0].fileno()
+
+    def handle_error(self, rquest, client_address):
+        """Override SocketServer.handle_error."""
+
+        self._logger.error(
+            'Exception in processing request from: %r\n%s',
+            client_address,
+            util.get_stack_trace())
+        # Note: client_address is a tuple.
+
+    def get_request(self):
+        """Override TCPServer.get_request to wrap OpenSSL.SSL.Connection
+        object with _StandaloneSSLConnection to provide makefile method. We
+        cannot substitute OpenSSL.SSL.Connection.makefile since it's readonly
+        attribute.
+        """
+
+        accepted_socket, client_address = self.socket.accept()
+        if self.websocket_server_options.use_tls and _HAS_OPEN_SSL:
+            accepted_socket = _StandaloneSSLConnection(accepted_socket)
+        return accepted_socket, client_address
+
+    def serve_forever(self, poll_interval=0.5):
+        """Override SocketServer.BaseServer.serve_forever."""
+
+        self.__ws_serving = True
+        self.__ws_is_shut_down.clear()
+        handle_request = self.handle_request
+        if hasattr(self, '_handle_request_noblock'):
+            handle_request = self._handle_request_noblock
+        else:
+            self._logger.warning('Fallback to blocking request handler')
+        try:
+            while self.__ws_serving:
+                r, w, e = select.select(
+                    [socket_[0] for socket_ in self._sockets],
+                    [], [], poll_interval)
+                for socket_ in r:
+                    self.socket = socket_
+                    handle_request()
+                self.socket = None
+        finally:
+            self.__ws_is_shut_down.set()
+
+    def shutdown(self):
+        """Override SocketServer.BaseServer.shutdown."""
+
+        self.__ws_serving = False
+        self.__ws_is_shut_down.wait()
+
+
+class WebSocketRequestHandler(CGIHTTPServer.CGIHTTPRequestHandler):
+    """CGIHTTPRequestHandler specialized for WebSocket."""
+
+    # Use httplib.HTTPMessage instead of mimetools.Message.
+    MessageClass = httplib.HTTPMessage
+
+    def setup(self):
+        """Override SocketServer.StreamRequestHandler.setup to wrap rfile
+        with MemorizingFile.
+
+        This method will be called by BaseRequestHandler's constructor
+        before calling BaseHTTPRequestHandler.handle.
+        BaseHTTPRequestHandler.handle will call
+        BaseHTTPRequestHandler.handle_one_request and it will call
+        WebSocketRequestHandler.parse_request.
+        """
+
+        # Call superclass's setup to prepare rfile, wfile, etc. See setup
+        # definition on the root class SocketServer.StreamRequestHandler to
+        # understand what this does.
+        CGIHTTPServer.CGIHTTPRequestHandler.setup(self)
+
+        self.rfile = memorizingfile.MemorizingFile(
+            self.rfile,
+            max_memorized_lines=_MAX_MEMORIZED_LINES)
+
+    def __init__(self, request, client_address, server):
+        self._logger = util.get_class_logger(self)
+
+        self._options = server.websocket_server_options
+
+        # Overrides CGIHTTPServerRequestHandler.cgi_directories.
+        self.cgi_directories = self._options.cgi_directories
+        # Replace CGIHTTPRequestHandler.is_executable method.
+        if self._options.is_executable_method is not None:
+            self.is_executable = self._options.is_executable_method
+
+        # This actually calls BaseRequestHandler.__init__.
+        CGIHTTPServer.CGIHTTPRequestHandler.__init__(
+            self, request, client_address, server)
+
+    def parse_request(self):
+        """Override BaseHTTPServer.BaseHTTPRequestHandler.parse_request.
+
+        Return True to continue processing for HTTP(S), False otherwise.
+
+        See BaseHTTPRequestHandler.handle_one_request method which calls
+        this method to understand how the return value will be handled.
+        """
+
+        # We hook parse_request method, but also call the original
+        # CGIHTTPRequestHandler.parse_request since when we return False,
+        # CGIHTTPRequestHandler.handle_one_request continues processing and
+        # it needs variables set by CGIHTTPRequestHandler.parse_request.
+        #
+        # Variables set by this method will be also used by WebSocket request
+        # handling (self.path, self.command, self.requestline, etc. See also
+        # how _StandaloneRequest's members are implemented using these
+        # attributes).
+        if not CGIHTTPServer.CGIHTTPRequestHandler.parse_request(self):
+            return False
+
+        if self._options.use_basic_auth:
+            auth = self.headers.getheader('Authorization')
+            if auth != self._options.basic_auth_credential:
+                self.send_response(401)
+                self.send_header('WWW-Authenticate',
+                                 'Basic realm="Pywebsocket"')
+                self.end_headers()
+                self._logger.info('Request basic authentication')
+                return True
+
+        host, port, resource = http_header_util.parse_uri(self.path)
+        if resource is None:
+            self._logger.info('Invalid URI: %r', self.path)
+            self._logger.info('Fallback to CGIHTTPRequestHandler')
+            return True
+        server_options = self.server.websocket_server_options
+        if host is not None:
+            validation_host = server_options.validation_host
+            if validation_host is not None and host != validation_host:
+                self._logger.info('Invalid host: %r (expected: %r)',
+                                  host,
+                                  validation_host)
+                self._logger.info('Fallback to CGIHTTPRequestHandler')
+                return True
+        if port is not None:
+            validation_port = server_options.validation_port
+            if validation_port is not None and port != validation_port:
+                self._logger.info('Invalid port: %r (expected: %r)',
+                                  port,
+                                  validation_port)
+                self._logger.info('Fallback to CGIHTTPRequestHandler')
+                return True
+        self.path = resource
+
+        request = _StandaloneRequest(self, self._options.use_tls)
+
+        try:
+            # Fallback to default http handler for request paths for which
+            # we don't have request handlers.
+            if not self._options.dispatcher.get_handler_suite(self.path):
+                self._logger.info('No handler for resource: %r',
+                                  self.path)
+                self._logger.info('Fallback to CGIHTTPRequestHandler')
+                return True
+        except dispatch.DispatchException, e:
+            self._logger.info('%s', e)
+            self.send_error(e.status)
+            return False
+
+        # If any Exceptions without except clause setup (including
+        # DispatchException) is raised below this point, it will be caught
+        # and logged by WebSocketServer.
+
+        try:
+            try:
+                handshake.do_handshake(
+                    request,
+                    self._options.dispatcher,
+                    allowDraft75=self._options.allow_draft75,
+                    strict=self._options.strict)
+            except handshake.VersionException, e:
+                self._logger.info('%s', e)
+                self.send_response(common.HTTP_STATUS_BAD_REQUEST)
+                self.send_header(common.SEC_WEBSOCKET_VERSION_HEADER,
+                                 e.supported_versions)
+                self.end_headers()
+                return False
+            except handshake.HandshakeException, e:
+                # Handshake for ws(s) failed.
+                self._logger.info('%s', e)
+                self.send_error(e.status)
+                return False
+
+            request._dispatcher = self._options.dispatcher
+            self._options.dispatcher.transfer_data(request)
+        except handshake.AbortedByUserException, e:
+            self._logger.info('%s', e)
+        return False
+
+    def log_request(self, code='-', size='-'):
+        """Override BaseHTTPServer.log_request."""
+
+        self._logger.info('"%s" %s %s',
+                          self.requestline, str(code), str(size))
+
+    def log_error(self, *args):
+        """Override BaseHTTPServer.log_error."""
+
+        # Despite the name, this method is for warnings than for errors.
+        # For example, HTTP status code is logged by this method.
+        self._logger.warning('%s - %s',
+                             self.address_string(),
+                             args[0] % args[1:])
+
+    def is_cgi(self):
+        """Test whether self.path corresponds to a CGI script.
+
+        Add extra check that self.path doesn't contains ..
+        Also check if the file is a executable file or not.
+        If the file is not executable, it is handled as static file or dir
+        rather than a CGI script.
+        """
+
+        if CGIHTTPServer.CGIHTTPRequestHandler.is_cgi(self):
+            if '..' in self.path:
+                return False
+            # strip query parameter from request path
+            resource_name = self.path.split('?', 2)[0]
+            # convert resource_name into real path name in filesystem.
+            scriptfile = self.translate_path(resource_name)
+            if not os.path.isfile(scriptfile):
+                return False
+            if not self.is_executable(scriptfile):
+                return False
+            return True
+        return False
+
+
+def _get_logger_from_class(c):
+    return logging.getLogger('%s.%s' % (c.__module__, c.__name__))
+
+
+def _configure_logging(options):
+    logging.addLevelName(common.LOGLEVEL_FINE, 'FINE')
+
+    logger = logging.getLogger()
+    logger.setLevel(logging.getLevelName(options.log_level.upper()))
+    if options.log_file:
+        handler = logging.handlers.RotatingFileHandler(
+                options.log_file, 'a', options.log_max, options.log_count)
+    else:
+        handler = logging.StreamHandler()
+    formatter = logging.Formatter(
+            '[%(asctime)s] [%(levelname)s] %(name)s: %(message)s')
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+
+    deflate_log_level_name = logging.getLevelName(
+        options.deflate_log_level.upper())
+    _get_logger_from_class(util._Deflater).setLevel(
+        deflate_log_level_name)
+    _get_logger_from_class(util._Inflater).setLevel(
+        deflate_log_level_name)
+
+
+def _build_option_parser():
+    parser = optparse.OptionParser()
+
+    parser.add_option('--config', dest='config_file', type='string',
+                      default=None,
+                      help=('Path to configuration file. See the file comment '
+                            'at the top of this file for the configuration '
+                            'file format'))
+    parser.add_option('-H', '--server-host', '--server_host',
+                      dest='server_host',
+                      default='',
+                      help='server hostname to listen to')
+    parser.add_option('-V', '--validation-host', '--validation_host',
+                      dest='validation_host',
+                      default=None,
+                      help='server hostname to validate in absolute path.')
+    parser.add_option('-p', '--port', dest='port', type='int',
+                      default=common.DEFAULT_WEB_SOCKET_PORT,
+                      help='port to listen to')
+    parser.add_option('-P', '--validation-port', '--validation_port',
+                      dest='validation_port', type='int',
+                      default=None,
+                      help='server port to validate in absolute path.')
+    parser.add_option('-w', '--websock-handlers', '--websock_handlers',
+                      dest='websock_handlers',
+                      default='.',
+                      help=('The root directory of WebSocket handler files. '
+                            'If the path is relative, --document-root is used '
+                            'as the base.'))
+    parser.add_option('-m', '--websock-handlers-map-file',
+                      '--websock_handlers_map_file',
+                      dest='websock_handlers_map_file',
+                      default=None,
+                      help=('WebSocket handlers map file. '
+                            'Each line consists of alias_resource_path and '
+                            'existing_resource_path, separated by spaces.'))
+    parser.add_option('-s', '--scan-dir', '--scan_dir', dest='scan_dir',
+                      default=None,
+                      help=('Must be a directory under --websock-handlers. '
+                            'Only handlers under this directory are scanned '
+                            'and registered to the server. '
+                            'Useful for saving scan time when the handler '
+                            'root directory contains lots of files that are '
+                            'not handler file or are handler files but you '
+                            'don\'t want them to be registered. '))
+    parser.add_option('--allow-handlers-outside-root-dir',
+                      '--allow_handlers_outside_root_dir',
+                      dest='allow_handlers_outside_root_dir',
+                      action='store_true',
+                      default=False,
+                      help=('Scans WebSocket handlers even if their canonical '
+                            'path is not under --websock-handlers.'))
+    parser.add_option('-d', '--document-root', '--document_root',
+                      dest='document_root', default='.',
+                      help='Document root directory.')
+    parser.add_option('-x', '--cgi-paths', '--cgi_paths', dest='cgi_paths',
+                      default=None,
+                      help=('CGI paths relative to document_root.'
+                            'Comma-separated. (e.g -x /cgi,/htbin) '
+                            'Files under document_root/cgi_path are handled '
+                            'as CGI programs. Must be executable.'))
+    parser.add_option('-t', '--tls', dest='use_tls', action='store_true',
+                      default=False, help='use TLS (wss://)')
+    parser.add_option('-k', '--private-key', '--private_key',
+                      dest='private_key',
+                      default='', help='TLS private key file.')
+    parser.add_option('-c', '--certificate', dest='certificate',
+                      default='', help='TLS certificate file.')
+    parser.add_option('--tls-client-auth', dest='tls_client_auth',
+                      action='store_true', default=False,
+                      help='Requires TLS client auth on every connection.')
+    parser.add_option('--tls-client-ca', dest='tls_client_ca', default='',
+                      help=('Specifies a pem file which contains a set of '
+                            'concatenated CA certificates which are used to '
+                            'validate certificates passed from clients'))
+    parser.add_option('--basic-auth', dest='use_basic_auth',
+                      action='store_true', default=False,
+                      help='Requires Basic authentication.')
+    parser.add_option('--basic-auth-credential',
+                      dest='basic_auth_credential', default='test:test',
+                      help='Specifies the credential of basic authentication '
+                      'by username:password pair (e.g. test:test).')
+    parser.add_option('-l', '--log-file', '--log_file', dest='log_file',
+                      default='', help='Log file.')
+    # Custom log level:
+    # - FINE: Prints status of each frame processing step
+    parser.add_option('--log-level', '--log_level', type='choice',
+                      dest='log_level', default='warn',
+                      choices=['fine',
+                               'debug', 'info', 'warning', 'warn', 'error',
+                               'critical'],
+                      help='Log level.')
+    parser.add_option('--deflate-log-level', '--deflate_log_level',
+                      type='choice',
+                      dest='deflate_log_level', default='warn',
+                      choices=['debug', 'info', 'warning', 'warn', 'error',
+                               'critical'],
+                      help='Log level for _Deflater and _Inflater.')
+    parser.add_option('--thread-monitor-interval-in-sec',
+                      '--thread_monitor_interval_in_sec',
+                      dest='thread_monitor_interval_in_sec',
+                      type='int', default=-1,
+                      help=('If positive integer is specified, run a thread '
+                            'monitor to show the status of server threads '
+                            'periodically in the specified inteval in '
+                            'second. If non-positive integer is specified, '
+                            'disable the thread monitor.'))
+    parser.add_option('--log-max', '--log_max', dest='log_max', type='int',
+                      default=_DEFAULT_LOG_MAX_BYTES,
+                      help='Log maximum bytes')
+    parser.add_option('--log-count', '--log_count', dest='log_count',
+                      type='int', default=_DEFAULT_LOG_BACKUP_COUNT,
+                      help='Log backup count')
+    parser.add_option('--allow-draft75', dest='allow_draft75',
+                      action='store_true', default=False,
+                      help='Obsolete option. Ignored.')
+    parser.add_option('--strict', dest='strict', action='store_true',
+                      default=False, help='Obsolete option. Ignored.')
+    parser.add_option('-q', '--queue', dest='request_queue_size', type='int',
+                      default=_DEFAULT_REQUEST_QUEUE_SIZE,
+                      help='request queue size')
+
+    return parser
+
+
+class ThreadMonitor(threading.Thread):
+    daemon = True
+
+    def __init__(self, interval_in_sec):
+        threading.Thread.__init__(self, name='ThreadMonitor')
+
+        self._logger = util.get_class_logger(self)
+
+        self._interval_in_sec = interval_in_sec
+
+    def run(self):
+        while True:
+            thread_name_list = []
+            for thread in threading.enumerate():
+                thread_name_list.append(thread.name)
+            self._logger.info(
+                "%d active threads: %s",
+                threading.active_count(),
+                ', '.join(thread_name_list))
+            time.sleep(self._interval_in_sec)
+
+
+def _parse_args_and_config(args):
+    parser = _build_option_parser()
+
+    # First, parse options without configuration file.
+    temporary_options, temporary_args = parser.parse_args(args=args)
+    if temporary_args:
+        logging.critical(
+            'Unrecognized positional arguments: %r', temporary_args)
+        sys.exit(1)
+
+    if temporary_options.config_file:
+        try:
+            config_fp = open(temporary_options.config_file, 'r')
+        except IOError, e:
+            logging.critical(
+                'Failed to open configuration file %r: %r',
+                temporary_options.config_file,
+                e)
+            sys.exit(1)
+
+        config_parser = ConfigParser.SafeConfigParser()
+        config_parser.readfp(config_fp)
+        config_fp.close()
+
+        args_from_config = []
+        for name, value in config_parser.items('pywebsocket'):
+            args_from_config.append('--' + name)
+            args_from_config.append(value)
+        if args is None:
+            args = args_from_config
+        else:
+            args = args_from_config + args
+        return parser.parse_args(args=args)
+    else:
+        return temporary_options, temporary_args
+
+
+def _main(args=None):
+    """You can call this function from your own program, but please note that
+    this function has some side-effects that might affect your program. For
+    example, util.wrap_popen3_for_win use in this method replaces implementation
+    of os.popen3.
+    """
+
+    options, args = _parse_args_and_config(args=args)
+
+    os.chdir(options.document_root)
+
+    _configure_logging(options)
+
+    # TODO(tyoshino): Clean up initialization of CGI related values. Move some
+    # of code here to WebSocketRequestHandler class if it's better.
+    options.cgi_directories = []
+    options.is_executable_method = None
+    if options.cgi_paths:
+        options.cgi_directories = options.cgi_paths.split(',')
+        if sys.platform in ('cygwin', 'win32'):
+            cygwin_path = None
+            # For Win32 Python, it is expected that CYGWIN_PATH
+            # is set to a directory of cygwin binaries.
+            # For example, websocket_server.py in Chromium sets CYGWIN_PATH to
+            # full path of third_party/cygwin/bin.
+            if 'CYGWIN_PATH' in os.environ:
+                cygwin_path = os.environ['CYGWIN_PATH']
+            util.wrap_popen3_for_win(cygwin_path)
+
+            def __check_script(scriptpath):
+                return util.get_script_interp(scriptpath, cygwin_path)
+
+            options.is_executable_method = __check_script
+
+    if options.use_tls:
+        if not (_HAS_SSL or _HAS_OPEN_SSL):
+            logging.critical('TLS support requires ssl or pyOpenSSL module.')
+            sys.exit(1)
+        if not options.private_key or not options.certificate:
+            logging.critical(
+                    'To use TLS, specify private_key and certificate.')
+            sys.exit(1)
+
+    if options.tls_client_auth:
+        if not options.use_tls:
+            logging.critical('TLS must be enabled for client authentication.')
+            sys.exit(1)
+        if not _HAS_SSL:
+            logging.critical('Client authentication requires ssl module.')
+
+    if not options.scan_dir:
+        options.scan_dir = options.websock_handlers
+
+    if options.use_basic_auth:
+        options.basic_auth_credential = 'Basic ' + base64.b64encode(
+            options.basic_auth_credential)
+
+    try:
+        if options.thread_monitor_interval_in_sec > 0:
+            # Run a thread monitor to show the status of server threads for
+            # debugging.
+            ThreadMonitor(options.thread_monitor_interval_in_sec).start()
+
+        server = WebSocketServer(options)
+        server.serve_forever()
+    except Exception, e:
+        logging.critical('mod_pywebsocket: %s' % e)
+        logging.critical('mod_pywebsocket: %s' % util.get_stack_trace())
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    _main(sys.argv[1:])
+
+
+# vi:sts=4 sw=4 et
diff --git a/module/lib/mod_pywebsocket/stream.py b/module/lib/mod_pywebsocket/stream.py
new file mode 100644
index 000000000..edc533279
--- /dev/null
+++ b/module/lib/mod_pywebsocket/stream.py
@@ -0,0 +1,57 @@
+# Copyright 2011, Google Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+"""This file exports public symbols.
+"""
+
+
+from mod_pywebsocket._stream_base import BadOperationException
+from mod_pywebsocket._stream_base import ConnectionTerminatedException
+from mod_pywebsocket._stream_base import InvalidFrameException
+from mod_pywebsocket._stream_base import InvalidUTF8Exception
+from mod_pywebsocket._stream_base import UnsupportedFrameException
+from mod_pywebsocket._stream_hixie75 import StreamHixie75
+from mod_pywebsocket._stream_hybi import Frame
+from mod_pywebsocket._stream_hybi import Stream
+from mod_pywebsocket._stream_hybi import StreamOptions
+
+# These methods are intended to be used by WebSocket client developers to have
+# their implementations receive broken data in tests.
+from mod_pywebsocket._stream_hybi import create_close_frame
+from mod_pywebsocket._stream_hybi import create_header
+from mod_pywebsocket._stream_hybi import create_length_header
+from mod_pywebsocket._stream_hybi import create_ping_frame
+from mod_pywebsocket._stream_hybi import create_pong_frame
+from mod_pywebsocket._stream_hybi import create_binary_frame
+from mod_pywebsocket._stream_hybi import create_text_frame
+from mod_pywebsocket._stream_hybi import create_closing_handshake_body
+
+
+# vi:sts=4 sw=4 et
diff --git a/module/lib/mod_pywebsocket/util.py b/module/lib/mod_pywebsocket/util.py
new file mode 100644
index 000000000..7bb0b5d9e
--- /dev/null
+++ b/module/lib/mod_pywebsocket/util.py
@@ -0,0 +1,515 @@
+# Copyright 2011, Google Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+"""WebSocket utilities.
+"""
+
+
+import array
+import errno
+
+# Import hash classes from a module available and recommended for each Python
+# version and re-export those symbol. Use sha and md5 module in Python 2.4, and
+# hashlib module in Python 2.6.
+try:
+    import hashlib
+    md5_hash = hashlib.md5
+    sha1_hash = hashlib.sha1
+except ImportError:
+    import md5
+    import sha
+    md5_hash = md5.md5
+    sha1_hash = sha.sha
+
+import StringIO
+import logging
+import os
+import re
+import socket
+import traceback
+import zlib
+
+
+def get_stack_trace():
+    """Get the current stack trace as string.
+
+    This is needed to support Python 2.3.
+    TODO: Remove this when we only support Python 2.4 and above.
+          Use traceback.format_exc instead.
+    """
+
+    out = StringIO.StringIO()
+    traceback.print_exc(file=out)
+    return out.getvalue()
+
+
+def prepend_message_to_exception(message, exc):
+    """Prepend message to the exception."""
+
+    exc.args = (message + str(exc),)
+    return
+
+
+def __translate_interp(interp, cygwin_path):
+    """Translate interp program path for Win32 python to run cygwin program
+    (e.g. perl).  Note that it doesn't support path that contains space,
+    which is typically true for Unix, where #!-script is written.
+    For Win32 python, cygwin_path is a directory of cygwin binaries.
+
+    Args:
+      interp: interp command line
+      cygwin_path: directory name of cygwin binary, or None
+    Returns:
+      translated interp command line.
+    """
+    if not cygwin_path:
+        return interp
+    m = re.match('^[^ ]*/([^ ]+)( .*)?', interp)
+    if m:
+        cmd = os.path.join(cygwin_path, m.group(1))
+        return cmd + m.group(2)
+    return interp
+
+
+def get_script_interp(script_path, cygwin_path=None):
+    """Gets #!-interpreter command line from the script.
+
+    It also fixes command path.  When Cygwin Python is used, e.g. in WebKit,
+    it could run "/usr/bin/perl -wT hello.pl".
+    When Win32 Python is used, e.g. in Chromium, it couldn't.  So, fix
+    "/usr/bin/perl" to "<cygwin_path>\perl.exe".
+
+    Args:
+      script_path: pathname of the script
+      cygwin_path: directory name of cygwin binary, or None
+    Returns:
+      #!-interpreter command line, or None if it is not #!-script.
+    """
+    fp = open(script_path)
+    line = fp.readline()
+    fp.close()
+    m = re.match('^#!(.*)', line)
+    if m:
+        return __translate_interp(m.group(1), cygwin_path)
+    return None
+
+
+def wrap_popen3_for_win(cygwin_path):
+    """Wrap popen3 to support #!-script on Windows.
+
+    Args:
+      cygwin_path:  path for cygwin binary if command path is needed to be
+                    translated.  None if no translation required.
+    """
+
+    __orig_popen3 = os.popen3
+
+    def __wrap_popen3(cmd, mode='t', bufsize=-1):
+        cmdline = cmd.split(' ')
+        interp = get_script_interp(cmdline[0], cygwin_path)
+        if interp:
+            cmd = interp + ' ' + cmd
+        return __orig_popen3(cmd, mode, bufsize)
+
+    os.popen3 = __wrap_popen3
+
+
+def hexify(s):
+    return ' '.join(map(lambda x: '%02x' % ord(x), s))
+
+
+def get_class_logger(o):
+    return logging.getLogger(
+        '%s.%s' % (o.__class__.__module__, o.__class__.__name__))
+
+
+class NoopMasker(object):
+    """A masking object that has the same interface as RepeatedXorMasker but
+    just returns the string passed in without making any change.
+    """
+
+    def __init__(self):
+        pass
+
+    def mask(self, s):
+        return s
+
+
+class RepeatedXorMasker(object):
+    """A masking object that applies XOR on the string given to mask method
+    with the masking bytes given to the constructor repeatedly. This object
+    remembers the position in the masking bytes the last mask method call
+    ended and resumes from that point on the next mask method call.
+    """
+
+    def __init__(self, mask):
+        self._mask = map(ord, mask)
+        self._mask_size = len(self._mask)
+        self._count = 0
+
+    def mask(self, s):
+        result = array.array('B')
+        result.fromstring(s)
+        # Use temporary local variables to eliminate the cost to access
+        # attributes
+        count = self._count
+        mask = self._mask
+        mask_size = self._mask_size
+        for i in xrange(len(result)):
+            result[i] ^= mask[count]
+            count = (count + 1) % mask_size
+        self._count = count
+
+        return result.tostring()
+
+
+class DeflateRequest(object):
+    """A wrapper class for request object to intercept send and recv to perform
+    deflate compression and decompression transparently.
+    """
+
+    def __init__(self, request):
+        self._request = request
+        self.connection = DeflateConnection(request.connection)
+
+    def __getattribute__(self, name):
+        if name in ('_request', 'connection'):
+            return object.__getattribute__(self, name)
+        return self._request.__getattribute__(name)
+
+    def __setattr__(self, name, value):
+        if name in ('_request', 'connection'):
+            return object.__setattr__(self, name, value)
+        return self._request.__setattr__(name, value)
+
+
+# By making wbits option negative, we can suppress CMF/FLG (2 octet) and
+# ADLER32 (4 octet) fields of zlib so that we can use zlib module just as
+# deflate library. DICTID won't be added as far as we don't set dictionary.
+# LZ77 window of 32K will be used for both compression and decompression.
+# For decompression, we can just use 32K to cover any windows size. For
+# compression, we use 32K so receivers must use 32K.
+#
+# Compression level is Z_DEFAULT_COMPRESSION. We don't have to match level
+# to decode.
+#
+# See zconf.h, deflate.cc, inflate.cc of zlib library, and zlibmodule.c of
+# Python. See also RFC1950 (ZLIB 3.3).
+
+
+class _Deflater(object):
+
+    def __init__(self, window_bits):
+        self._logger = get_class_logger(self)
+
+        self._compress = zlib.compressobj(
+            zlib.Z_DEFAULT_COMPRESSION, zlib.DEFLATED, -window_bits)
+
+    def compress(self, bytes):
+        compressed_bytes = self._compress.compress(bytes)
+        self._logger.debug('Compress input %r', bytes)
+        self._logger.debug('Compress result %r', compressed_bytes)
+        return compressed_bytes
+
+    def compress_and_flush(self, bytes):
+        compressed_bytes = self._compress.compress(bytes)
+        compressed_bytes += self._compress.flush(zlib.Z_SYNC_FLUSH)
+        self._logger.debug('Compress input %r', bytes)
+        self._logger.debug('Compress result %r', compressed_bytes)
+        return compressed_bytes
+
+    def compress_and_finish(self, bytes):
+        compressed_bytes = self._compress.compress(bytes)
+        compressed_bytes += self._compress.flush(zlib.Z_FINISH)
+        self._logger.debug('Compress input %r', bytes)
+        self._logger.debug('Compress result %r', compressed_bytes)
+        return compressed_bytes
+
+class _Inflater(object):
+
+    def __init__(self):
+        self._logger = get_class_logger(self)
+
+        self._unconsumed = ''
+
+        self.reset()
+
+    def decompress(self, size):
+        if not (size == -1 or size > 0):
+            raise Exception('size must be -1 or positive')
+
+        data = ''
+
+        while True:
+            if size == -1:
+                data += self._decompress.decompress(self._unconsumed)
+                # See Python bug http://bugs.python.org/issue12050 to
+                # understand why the same code cannot be used for updating
+                # self._unconsumed for here and else block.
+                self._unconsumed = ''
+            else:
+                data += self._decompress.decompress(
+                    self._unconsumed, size - len(data))
+                self._unconsumed = self._decompress.unconsumed_tail
+            if self._decompress.unused_data:
+                # Encountered a last block (i.e. a block with BFINAL = 1) and
+                # found a new stream (unused_data). We cannot use the same
+                # zlib.Decompress object for the new stream. Create a new
+                # Decompress object to decompress the new one.
+                #
+                # It's fine to ignore unconsumed_tail if unused_data is not
+                # empty.
+                self._unconsumed = self._decompress.unused_data
+                self.reset()
+                if size >= 0 and len(data) == size:
+                    # data is filled. Don't call decompress again.
+                    break
+                else:
+                    # Re-invoke Decompress.decompress to try to decompress all
+                    # available bytes before invoking read which blocks until
+                    # any new byte is available.
+                    continue
+            else:
+                # Here, since unused_data is empty, even if unconsumed_tail is
+                # not empty, bytes of requested length are already in data. We
+                # don't have to "continue" here.
+                break
+
+        if data:
+            self._logger.debug('Decompressed %r', data)
+        return data
+
+    def append(self, data):
+        self._logger.debug('Appended %r', data)
+        self._unconsumed += data
+
+    def reset(self):
+        self._logger.debug('Reset')
+        self._decompress = zlib.decompressobj(-zlib.MAX_WBITS)
+
+
+# Compresses/decompresses given octets using the method introduced in RFC1979.
+
+
+class _RFC1979Deflater(object):
+    """A compressor class that applies DEFLATE to given byte sequence and
+    flushes using the algorithm described in the RFC1979 section 2.1.
+    """
+
+    def __init__(self, window_bits, no_context_takeover):
+        self._deflater = None
+        if window_bits is None:
+            window_bits = zlib.MAX_WBITS
+        self._window_bits = window_bits
+        self._no_context_takeover = no_context_takeover
+
+    def filter(self, bytes, flush=True, bfinal=False):
+        if self._deflater is None or (self._no_context_takeover and flush):
+            self._deflater = _Deflater(self._window_bits)
+
+        if bfinal:
+            result = self._deflater.compress_and_finish(bytes)
+            # Add a padding block with BFINAL = 0 and BTYPE = 0.
+            result = result + chr(0)
+            self._deflater = None
+            return result
+        if flush:
+            # Strip last 4 octets which is LEN and NLEN field of a
+            # non-compressed block added for Z_SYNC_FLUSH.
+            return self._deflater.compress_and_flush(bytes)[:-4]
+        return self._deflater.compress(bytes)
+
+class _RFC1979Inflater(object):
+    """A decompressor class for byte sequence compressed and flushed following
+    the algorithm described in the RFC1979 section 2.1.
+    """
+
+    def __init__(self):
+        self._inflater = _Inflater()
+
+    def filter(self, bytes):
+        # Restore stripped LEN and NLEN field of a non-compressed block added
+        # for Z_SYNC_FLUSH.
+        self._inflater.append(bytes + '\x00\x00\xff\xff')
+        return self._inflater.decompress(-1)
+
+
+class DeflateSocket(object):
+    """A wrapper class for socket object to intercept send and recv to perform
+    deflate compression and decompression transparently.
+    """
+
+    # Size of the buffer passed to recv to receive compressed data.
+    _RECV_SIZE = 4096
+
+    def __init__(self, socket):
+        self._socket = socket
+
+        self._logger = get_class_logger(self)
+
+        self._deflater = _Deflater(zlib.MAX_WBITS)
+        self._inflater = _Inflater()
+
+    def recv(self, size):
+        """Receives data from the socket specified on the construction up
+        to the specified size. Once any data is available, returns it even
+        if it's smaller than the specified size.
+        """
+
+        # TODO(tyoshino): Allow call with size=0. It should block until any
+        # decompressed data is available.
+        if size <= 0:
+            raise Exception('Non-positive size passed')
+        while True:
+            data = self._inflater.decompress(size)
+            if len(data) != 0:
+                return data
+
+            read_data = self._socket.recv(DeflateSocket._RECV_SIZE)
+            if not read_data:
+                return ''
+            self._inflater.append(read_data)
+
+    def sendall(self, bytes):
+        self.send(bytes)
+
+    def send(self, bytes):
+        self._socket.sendall(self._deflater.compress_and_flush(bytes))
+        return len(bytes)
+
+
+class DeflateConnection(object):
+    """A wrapper class for request object to intercept write and read to
+    perform deflate compression and decompression transparently.
+    """
+
+    def __init__(self, connection):
+        self._connection = connection
+
+        self._logger = get_class_logger(self)
+
+        self._deflater = _Deflater(zlib.MAX_WBITS)
+        self._inflater = _Inflater()
+
+    def get_remote_addr(self):
+        return self._connection.remote_addr
+    remote_addr = property(get_remote_addr)
+
+    def put_bytes(self, bytes):
+        self.write(bytes)
+
+    def read(self, size=-1):
+        """Reads at most size bytes. Blocks until there's at least one byte
+        available.
+        """
+
+        # TODO(tyoshino): Allow call with size=0.
+        if not (size == -1 or size > 0):
+            raise Exception('size must be -1 or positive')
+
+        data = ''
+        while True:
+            if size == -1:
+                data += self._inflater.decompress(-1)
+            else:
+                data += self._inflater.decompress(size - len(data))
+
+            if size >= 0 and len(data) != 0:
+                break
+
+            # TODO(tyoshino): Make this read efficient by some workaround.
+            #
+            # In 3.0.3 and prior of mod_python, read blocks until length bytes
+            # was read. We don't know the exact size to read while using
+            # deflate, so read byte-by-byte.
+            #
+            # _StandaloneRequest.read that ultimately performs
+            # socket._fileobject.read also blocks until length bytes was read
+            read_data = self._connection.read(1)
+            if not read_data:
+                break
+            self._inflater.append(read_data)
+        return data
+
+    def write(self, bytes):
+        self._connection.write(self._deflater.compress_and_flush(bytes))
+
+
+def _is_ewouldblock_errno(error_number):
+    """Returns True iff error_number indicates that receive operation would
+    block. To make this portable, we check availability of errno and then
+    compare them.
+    """
+
+    for error_name in ['WSAEWOULDBLOCK', 'EWOULDBLOCK', 'EAGAIN']:
+        if (error_name in dir(errno) and
+            error_number == getattr(errno, error_name)):
+            return True
+    return False
+
+
+def drain_received_data(raw_socket):
+    # Set the socket non-blocking.
+    original_timeout = raw_socket.gettimeout()
+    raw_socket.settimeout(0.0)
+
+    drained_data = []
+
+    # Drain until the socket is closed or no data is immediately
+    # available for read.
+    while True:
+        try:
+            data = raw_socket.recv(1)
+            if not data:
+                break
+            drained_data.append(data)
+        except socket.error, e:
+            # e can be either a pair (errno, string) or just a string (or
+            # something else) telling what went wrong. We suppress only
+            # the errors that indicates that the socket blocks. Those
+            # exceptions can be parsed as a pair (errno, string).
+            try:
+                error_number, message = e
+            except:
+                # Failed to parse socket.error.
+                raise e
+
+            if _is_ewouldblock_errno(error_number):
+                break
+            else:
+                raise e
+
+    # Rollback timeout value.
+    raw_socket.settimeout(original_timeout)
+
+    return ''.join(drained_data)
+
+
+# vi:sts=4 sw=4 et
diff --git a/module/lib/new_collections.py b/module/lib/new_collections.py
new file mode 100644
index 000000000..12d05b4b9
--- /dev/null
+++ b/module/lib/new_collections.py
@@ -0,0 +1,375 @@
+## {{{ http://code.activestate.com/recipes/576693/ (r9)
+# Backport of OrderedDict() class that runs on Python 2.4, 2.5, 2.6, 2.7 and pypy.
+# Passes Python2.7's test suite and incorporates all the latest updates.
+
+try:
+    from thread import get_ident as _get_ident
+except ImportError:
+    from dummy_thread import get_ident as _get_ident
+
+try:
+    from _abcoll import KeysView, ValuesView, ItemsView
+except ImportError:
+    pass
+
+
+class OrderedDict(dict):
+    'Dictionary that remembers insertion order'
+    # An inherited dict maps keys to values.
+    # The inherited dict provides __getitem__, __len__, __contains__, and get.
+    # The remaining methods are order-aware.
+    # Big-O running times for all methods are the same as for regular dictionaries.
+
+    # The internal self.__map dictionary maps keys to links in a doubly linked list.
+    # The circular doubly linked list starts and ends with a sentinel element.
+    # The sentinel element never gets deleted (this simplifies the algorithm).
+    # Each link is stored as a list of length three:  [PREV, NEXT, KEY].
+
+    def __init__(self, *args, **kwds):
+        '''Initialize an ordered dictionary.  Signature is the same as for
+        regular dictionaries, but keyword arguments are not recommended
+        because their insertion order is arbitrary.
+
+        '''
+        if len(args) > 1:
+            raise TypeError('expected at most 1 arguments, got %d' % len(args))
+        try:
+            self.__root
+        except AttributeError:
+            self.__root = root = []                     # sentinel node
+            root[:] = [root, root, None]
+            self.__map = {}
+        self.__update(*args, **kwds)
+
+    def __setitem__(self, key, value, dict_setitem=dict.__setitem__):
+        'od.__setitem__(i, y) <==> od[i]=y'
+        # Setting a new item creates a new link which goes at the end of the linked
+        # list, and the inherited dictionary is updated with the new key/value pair.
+        if key not in self:
+            root = self.__root
+            last = root[0]
+            last[1] = root[0] = self.__map[key] = [last, root, key]
+        dict_setitem(self, key, value)
+
+    def __delitem__(self, key, dict_delitem=dict.__delitem__):
+        'od.__delitem__(y) <==> del od[y]'
+        # Deleting an existing item uses self.__map to find the link which is
+        # then removed by updating the links in the predecessor and successor nodes.
+        dict_delitem(self, key)
+        link_prev, link_next, key = self.__map.pop(key)
+        link_prev[1] = link_next
+        link_next[0] = link_prev
+
+    def __iter__(self):
+        'od.__iter__() <==> iter(od)'
+        root = self.__root
+        curr = root[1]
+        while curr is not root:
+            yield curr[2]
+            curr = curr[1]
+
+    def __reversed__(self):
+        'od.__reversed__() <==> reversed(od)'
+        root = self.__root
+        curr = root[0]
+        while curr is not root:
+            yield curr[2]
+            curr = curr[0]
+
+    def clear(self):
+        'od.clear() -> None.  Remove all items from od.'
+        try:
+            for node in self.__map.itervalues():
+                del node[:]
+            root = self.__root
+            root[:] = [root, root, None]
+            self.__map.clear()
+        except AttributeError:
+            pass
+        dict.clear(self)
+
+    def popitem(self, last=True):
+        '''od.popitem() -> (k, v), return and remove a (key, value) pair.
+        Pairs are returned in LIFO order if last is true or FIFO order if false.
+
+        '''
+        if not self:
+            raise KeyError('dictionary is empty')
+        root = self.__root
+        if last:
+            link = root[0]
+            link_prev = link[0]
+            link_prev[1] = root
+            root[0] = link_prev
+        else:
+            link = root[1]
+            link_next = link[1]
+            root[1] = link_next
+            link_next[0] = root
+        key = link[2]
+        del self.__map[key]
+        value = dict.pop(self, key)
+        return key, value
+
+    # -- the following methods do not depend on the internal structure --
+
+    def keys(self):
+        'od.keys() -> list of keys in od'
+        return list(self)
+
+    def values(self):
+        'od.values() -> list of values in od'
+        return [self[key] for key in self]
+
+    def items(self):
+        'od.items() -> list of (key, value) pairs in od'
+        return [(key, self[key]) for key in self]
+
+    def iterkeys(self):
+        'od.iterkeys() -> an iterator over the keys in od'
+        return iter(self)
+
+    def itervalues(self):
+        'od.itervalues -> an iterator over the values in od'
+        for k in self:
+            yield self[k]
+
+    def iteritems(self):
+        'od.iteritems -> an iterator over the (key, value) items in od'
+        for k in self:
+            yield (k, self[k])
+
+    def update(*args, **kwds):
+        '''od.update(E, **F) -> None.  Update od from dict/iterable E and F.
+
+        If E is a dict instance, does:           for k in E: od[k] = E[k]
+        If E has a .keys() method, does:         for k in E.keys(): od[k] = E[k]
+        Or if E is an iterable of items, does:   for k, v in E: od[k] = v
+        In either case, this is followed by:     for k, v in F.items(): od[k] = v
+
+        '''
+        if len(args) > 2:
+            raise TypeError('update() takes at most 2 positional '
+                            'arguments (%d given)' % (len(args),))
+        elif not args:
+            raise TypeError('update() takes at least 1 argument (0 given)')
+        self = args[0]
+        # Make progressively weaker assumptions about "other"
+        other = ()
+        if len(args) == 2:
+            other = args[1]
+        if isinstance(other, dict):
+            for key in other:
+                self[key] = other[key]
+        elif hasattr(other, 'keys'):
+            for key in other.keys():
+                self[key] = other[key]
+        else:
+            for key, value in other:
+                self[key] = value
+        for key, value in kwds.items():
+            self[key] = value
+
+    __update = update  # let subclasses override update without breaking __init__
+
+    __marker = object()
+
+    def pop(self, key, default=__marker):
+        '''od.pop(k[,d]) -> v, remove specified key and return the corresponding value.
+        If key is not found, d is returned if given, otherwise KeyError is raised.
+
+        '''
+        if key in self:
+            result = self[key]
+            del self[key]
+            return result
+        if default is self.__marker:
+            raise KeyError(key)
+        return default
+
+    def setdefault(self, key, default=None):
+        'od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od'
+        if key in self:
+            return self[key]
+        self[key] = default
+        return default
+
+    def __repr__(self, _repr_running={}):
+        'od.__repr__() <==> repr(od)'
+        call_key = id(self), _get_ident()
+        if call_key in _repr_running:
+            return '...'
+        _repr_running[call_key] = 1
+        try:
+            if not self:
+                return '%s()' % (self.__class__.__name__,)
+            return '%s(%r)' % (self.__class__.__name__, self.items())
+        finally:
+            del _repr_running[call_key]
+
+    def __reduce__(self):
+        'Return state information for pickling'
+        items = [[k, self[k]] for k in self]
+        inst_dict = vars(self).copy()
+        for k in vars(OrderedDict()):
+            inst_dict.pop(k, None)
+        if inst_dict:
+            return (self.__class__, (items,), inst_dict)
+        return self.__class__, (items,)
+
+    def copy(self):
+        'od.copy() -> a shallow copy of od'
+        return self.__class__(self)
+
+    @classmethod
+    def fromkeys(cls, iterable, value=None):
+        '''OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S
+        and values equal to v (which defaults to None).
+
+        '''
+        d = cls()
+        for key in iterable:
+            d[key] = value
+        return d
+
+    def __eq__(self, other):
+        '''od.__eq__(y) <==> od==y.  Comparison to another OD is order-sensitive
+        while comparison to a regular mapping is order-insensitive.
+
+        '''
+        if isinstance(other, OrderedDict):
+            return len(self)==len(other) and self.items() == other.items()
+        return dict.__eq__(self, other)
+
+    def __ne__(self, other):
+        return not self == other
+
+    # -- the following methods are only used in Python 2.7 --
+
+    def viewkeys(self):
+        "od.viewkeys() -> a set-like object providing a view on od's keys"
+        return KeysView(self)
+
+    def viewvalues(self):
+        "od.viewvalues() -> an object providing a view on od's values"
+        return ValuesView(self)
+
+    def viewitems(self):
+        "od.viewitems() -> a set-like object providing a view on od's items"
+        return ItemsView(self)
+## end of http://code.activestate.com/recipes/576693/ }}}
+
+## {{{ http://code.activestate.com/recipes/500261/ (r15)
+from operator import itemgetter as _itemgetter
+from keyword import iskeyword as _iskeyword
+import sys as _sys
+
+def namedtuple(typename, field_names, verbose=False, rename=False):
+    """Returns a new subclass of tuple with named fields.
+
+    >>> Point = namedtuple('Point', 'x y')
+    >>> Point.__doc__                   # docstring for the new class
+    'Point(x, y)'
+    >>> p = Point(11, y=22)             # instantiate with positional args or keywords
+    >>> p[0] + p[1]                     # indexable like a plain tuple
+    33
+    >>> x, y = p                        # unpack like a regular tuple
+    >>> x, y
+    (11, 22)
+    >>> p.x + p.y                       # fields also accessable by name
+    33
+    >>> d = p._asdict()                 # convert to a dictionary
+    >>> d['x']
+    11
+    >>> Point(**d)                      # convert from a dictionary
+    Point(x=11, y=22)
+    >>> p._replace(x=100)               # _replace() is like str.replace() but targets named fields
+    Point(x=100, y=22)
+
+    """
+
+    # Parse and validate the field names.  Validation serves two purposes,
+    # generating informative error messages and preventing template injection attacks.
+    if isinstance(field_names, basestring):
+        field_names = field_names.replace(',', ' ').split() # names separated by whitespace and/or commas
+    field_names = tuple(map(str, field_names))
+    if rename:
+        names = list(field_names)
+        seen = set()
+        for i, name in enumerate(names):
+            if (not min(c.isalnum() or c=='_' for c in name) or _iskeyword(name)
+                or not name or name[0].isdigit() or name.startswith('_')
+                or name in seen):
+                    names[i] = '_%d' % i
+            seen.add(name)
+        field_names = tuple(names)
+    for name in (typename,) + field_names:
+        if not min(c.isalnum() or c=='_' for c in name):
+            raise ValueError('Type names and field names can only contain alphanumeric characters and underscores: %r' % name)
+        if _iskeyword(name):
+            raise ValueError('Type names and field names cannot be a keyword: %r' % name)
+        if name[0].isdigit():
+            raise ValueError('Type names and field names cannot start with a number: %r' % name)
+    seen_names = set()
+    for name in field_names:
+        if name.startswith('_') and not rename:
+            raise ValueError('Field names cannot start with an underscore: %r' % name)
+        if name in seen_names:
+            raise ValueError('Encountered duplicate field name: %r' % name)
+        seen_names.add(name)
+
+    # Create and fill-in the class template
+    numfields = len(field_names)
+    argtxt = repr(field_names).replace("'", "")[1:-1]   # tuple repr without parens or quotes
+    reprtxt = ', '.join('%s=%%r' % name for name in field_names)
+    template = '''class %(typename)s(tuple):
+        '%(typename)s(%(argtxt)s)' \n
+        __slots__ = () \n
+        _fields = %(field_names)r \n
+        def __new__(_cls, %(argtxt)s):
+            return _tuple.__new__(_cls, (%(argtxt)s)) \n
+        @classmethod
+        def _make(cls, iterable, new=tuple.__new__, len=len):
+            'Make a new %(typename)s object from a sequence or iterable'
+            result = new(cls, iterable)
+            if len(result) != %(numfields)d:
+                raise TypeError('Expected %(numfields)d arguments, got %%d' %% len(result))
+            return result \n
+        def __repr__(self):
+            return '%(typename)s(%(reprtxt)s)' %% self \n
+        def _asdict(self):
+            'Return a new dict which maps field names to their values'
+            return dict(zip(self._fields, self)) \n
+        def _replace(_self, **kwds):
+            'Return a new %(typename)s object replacing specified fields with new values'
+            result = _self._make(map(kwds.pop, %(field_names)r, _self))
+            if kwds:
+                raise ValueError('Got unexpected field names: %%r' %% kwds.keys())
+            return result \n
+        def __getnewargs__(self):
+            return tuple(self) \n\n''' % locals()
+    for i, name in enumerate(field_names):
+        template += '        %s = _property(_itemgetter(%d))\n' % (name, i)
+    if verbose:
+        print template
+
+    # Execute the template string in a temporary namespace
+    namespace = dict(_itemgetter=_itemgetter, __name__='namedtuple_%s' % typename,
+                     _property=property, _tuple=tuple)
+    try:
+        exec template in namespace
+    except SyntaxError, e:
+        raise SyntaxError(e.message + ':\n' + template)
+    result = namespace[typename]
+
+    # For pickling to work, the __module__ variable needs to be set to the frame
+    # where the named tuple is created.  Bypass this step in enviroments where
+    # sys._getframe is not defined (Jython for example) or sys._getframe is not
+    # defined for arguments greater than 0 (IronPython).
+    try:
+        result.__module__ = _sys._getframe(1).f_globals.get('__name__', '__main__')
+    except (AttributeError, ValueError):
+        pass
+
+    return result
+## end of http://code.activestate.com/recipes/500261/ }}}
diff --git a/module/lib/thrift/TSCons.py b/module/lib/thrift/TSCons.py
deleted file mode 100644
index 24046256c..000000000
--- a/module/lib/thrift/TSCons.py
+++ /dev/null
@@ -1,33 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-from os import path
-from SCons.Builder import Builder
-
-def scons_env(env, add=''):
-  opath = path.dirname(path.abspath('$TARGET'))
-  lstr = 'thrift --gen cpp -o ' + opath + ' ' + add + ' $SOURCE'
-  cppbuild = Builder(action = lstr)
-  env.Append(BUILDERS = {'ThriftCpp' : cppbuild})
-
-def gen_cpp(env, dir, file):
-  scons_env(env)
-  suffixes = ['_types.h', '_types.cpp']
-  targets = map(lambda s: 'gen-cpp/' + file + s, suffixes)
-  return env.ThriftCpp(targets, dir+file+'.thrift')
diff --git a/module/lib/thrift/TSerialization.py b/module/lib/thrift/TSerialization.py
deleted file mode 100644
index b19f98aa8..000000000
--- a/module/lib/thrift/TSerialization.py
+++ /dev/null
@@ -1,34 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-from protocol import TBinaryProtocol
-from transport import TTransport
-
-def serialize(thrift_object, protocol_factory = TBinaryProtocol.TBinaryProtocolFactory()):
-    transport = TTransport.TMemoryBuffer()
-    protocol = protocol_factory.getProtocol(transport)
-    thrift_object.write(protocol)
-    return transport.getvalue()
-
-def deserialize(base, buf, protocol_factory = TBinaryProtocol.TBinaryProtocolFactory()):
-    transport = TTransport.TMemoryBuffer(buf)
-    protocol = protocol_factory.getProtocol(transport)
-    base.read(protocol)
-    return base
-
diff --git a/module/lib/thrift/Thrift.py b/module/lib/thrift/Thrift.py
deleted file mode 100644
index 1d271fcff..000000000
--- a/module/lib/thrift/Thrift.py
+++ /dev/null
@@ -1,154 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-import sys
-
-class TType:
-  STOP   = 0
-  VOID   = 1
-  BOOL   = 2
-  BYTE   = 3
-  I08    = 3
-  DOUBLE = 4
-  I16    = 6
-  I32    = 8
-  I64    = 10
-  STRING = 11
-  UTF7   = 11
-  STRUCT = 12
-  MAP    = 13
-  SET    = 14
-  LIST   = 15
-  UTF8   = 16
-  UTF16  = 17
-
-  _VALUES_TO_NAMES = ( 'STOP',
-                      'VOID',
-                      'BOOL',
-                      'BYTE',
-                      'DOUBLE',
-                      None,
-                      'I16',
-                      None,
-                      'I32',
-                      None,
-                       'I64',
-                       'STRING',
-                       'STRUCT',
-                       'MAP',
-                       'SET',
-                       'LIST',
-                       'UTF8',
-                       'UTF16' )
-
-class TMessageType:
-  CALL  = 1
-  REPLY = 2
-  EXCEPTION = 3
-  ONEWAY = 4
-
-class TProcessor:
-
-  """Base class for procsessor, which works on two streams."""
-
-  def process(iprot, oprot):
-    pass
-
-class TException(Exception):
-
-  """Base class for all thrift exceptions."""
-
-  # BaseException.message is deprecated in Python v[2.6,3.0)
-  if (2,6,0) <= sys.version_info < (3,0):
-    def _get_message(self):
-	    return self._message
-    def _set_message(self, message):
-	    self._message = message
-    message = property(_get_message, _set_message)
-
-  def __init__(self, message=None):
-    Exception.__init__(self, message)
-    self.message = message
-
-class TApplicationException(TException):
-
-  """Application level thrift exceptions."""
-
-  UNKNOWN = 0
-  UNKNOWN_METHOD = 1
-  INVALID_MESSAGE_TYPE = 2
-  WRONG_METHOD_NAME = 3
-  BAD_SEQUENCE_ID = 4
-  MISSING_RESULT = 5
-  INTERNAL_ERROR = 6
-  PROTOCOL_ERROR = 7
-
-  def __init__(self, type=UNKNOWN, message=None):
-    TException.__init__(self, message)
-    self.type = type
-
-  def __str__(self):
-    if self.message:
-      return self.message
-    elif self.type == self.UNKNOWN_METHOD:
-      return 'Unknown method'
-    elif self.type == self.INVALID_MESSAGE_TYPE:
-      return 'Invalid message type'
-    elif self.type == self.WRONG_METHOD_NAME:
-      return 'Wrong method name'
-    elif self.type == self.BAD_SEQUENCE_ID:
-      return 'Bad sequence ID'
-    elif self.type == self.MISSING_RESULT:
-      return 'Missing result'
-    else:
-      return 'Default (unknown) TApplicationException'
-
-  def read(self, iprot):
-    iprot.readStructBegin()
-    while True:
-      (fname, ftype, fid) = iprot.readFieldBegin()
-      if ftype == TType.STOP:
-        break
-      if fid == 1:
-        if ftype == TType.STRING:
-          self.message = iprot.readString();
-        else:
-          iprot.skip(ftype)
-      elif fid == 2:
-        if ftype == TType.I32:
-          self.type = iprot.readI32();
-        else:
-          iprot.skip(ftype)
-      else:
-        iprot.skip(ftype)
-      iprot.readFieldEnd()
-    iprot.readStructEnd()
-
-  def write(self, oprot):
-    oprot.writeStructBegin('TApplicationException')
-    if self.message != None:
-      oprot.writeFieldBegin('message', TType.STRING, 1)
-      oprot.writeString(self.message)
-      oprot.writeFieldEnd()
-    if self.type != None:
-      oprot.writeFieldBegin('type', TType.I32, 2)
-      oprot.writeI32(self.type)
-      oprot.writeFieldEnd()
-    oprot.writeFieldStop()
-    oprot.writeStructEnd()
diff --git a/module/lib/thrift/__init__.py b/module/lib/thrift/__init__.py
deleted file mode 100644
index 48d659c40..000000000
--- a/module/lib/thrift/__init__.py
+++ /dev/null
@@ -1,20 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-__all__ = ['Thrift', 'TSCons']
diff --git a/module/lib/thrift/protocol/TBase.py b/module/lib/thrift/protocol/TBase.py
deleted file mode 100644
index e675c7dc0..000000000
--- a/module/lib/thrift/protocol/TBase.py
+++ /dev/null
@@ -1,72 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-from thrift.Thrift import *
-from thrift.protocol import TBinaryProtocol
-from thrift.transport import TTransport
-
-try:
-  from thrift.protocol import fastbinary
-except:
-  fastbinary = None
-
-class TBase(object):
-  __slots__ = []
-
-  def __repr__(self):
-    L = ['%s=%r' % (key, getattr(self, key))
-              for key in self.__slots__ ]
-    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
-
-  def __eq__(self, other):
-    if not isinstance(other, self.__class__):
-      return False
-    for attr in self.__slots__:
-      my_val = getattr(self, attr)
-      other_val = getattr(other, attr)
-      if my_val != other_val:
-        return False
-    return True
-    
-  def __ne__(self, other):
-    return not (self == other)
-  
-  def read(self, iprot):
-    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
-      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
-      return
-    iprot.readStruct(self, self.thrift_spec)
-
-  def write(self, oprot):
-    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
-      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
-      return
-    oprot.writeStruct(self, self.thrift_spec)
-
-class TExceptionBase(Exception):
-  # old style class so python2.4 can raise exceptions derived from this
-  #  This can't inherit from TBase because of that limitation.
-  __slots__ = []
-  
-  __repr__ = TBase.__repr__.im_func
-  __eq__ = TBase.__eq__.im_func
-  __ne__ = TBase.__ne__.im_func
-  read = TBase.read.im_func
-  write = TBase.write.im_func
-  
diff --git a/module/lib/thrift/protocol/TBinaryProtocol.py b/module/lib/thrift/protocol/TBinaryProtocol.py
deleted file mode 100644
index 50c6aa896..000000000
--- a/module/lib/thrift/protocol/TBinaryProtocol.py
+++ /dev/null
@@ -1,259 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-from TProtocol import *
-from struct import pack, unpack
-
-class TBinaryProtocol(TProtocolBase):
-
-  """Binary implementation of the Thrift protocol driver."""
-
-  # NastyHaxx. Python 2.4+ on 32-bit machines forces hex constants to be
-  # positive, converting this into a long. If we hardcode the int value
-  # instead it'll stay in 32 bit-land.
-
-  # VERSION_MASK = 0xffff0000
-  VERSION_MASK = -65536
-
-  # VERSION_1 = 0x80010000
-  VERSION_1 = -2147418112
-
-  TYPE_MASK = 0x000000ff
-
-  def __init__(self, trans, strictRead=False, strictWrite=True):
-    TProtocolBase.__init__(self, trans)
-    self.strictRead = strictRead
-    self.strictWrite = strictWrite
-
-  def writeMessageBegin(self, name, type, seqid):
-    if self.strictWrite:
-      self.writeI32(TBinaryProtocol.VERSION_1 | type)
-      self.writeString(name)
-      self.writeI32(seqid)
-    else:
-      self.writeString(name)
-      self.writeByte(type)
-      self.writeI32(seqid)
-
-  def writeMessageEnd(self):
-    pass
-
-  def writeStructBegin(self, name):
-    pass
-
-  def writeStructEnd(self):
-    pass
-
-  def writeFieldBegin(self, name, type, id):
-    self.writeByte(type)
-    self.writeI16(id)
-
-  def writeFieldEnd(self):
-    pass
-
-  def writeFieldStop(self):
-    self.writeByte(TType.STOP);
-
-  def writeMapBegin(self, ktype, vtype, size):
-    self.writeByte(ktype)
-    self.writeByte(vtype)
-    self.writeI32(size)
-
-  def writeMapEnd(self):
-    pass
-
-  def writeListBegin(self, etype, size):
-    self.writeByte(etype)
-    self.writeI32(size)
-
-  def writeListEnd(self):
-    pass
-
-  def writeSetBegin(self, etype, size):
-    self.writeByte(etype)
-    self.writeI32(size)
-
-  def writeSetEnd(self):
-    pass
-
-  def writeBool(self, bool):
-    if bool:
-      self.writeByte(1)
-    else:
-      self.writeByte(0)
-
-  def writeByte(self, byte):
-    buff = pack("!b", byte)
-    self.trans.write(buff)
-
-  def writeI16(self, i16):
-    buff = pack("!h", i16)
-    self.trans.write(buff)
-
-  def writeI32(self, i32):
-    buff = pack("!i", i32)
-    self.trans.write(buff)
-
-  def writeI64(self, i64):
-    buff = pack("!q", i64)
-    self.trans.write(buff)
-
-  def writeDouble(self, dub):
-    buff = pack("!d", dub)
-    self.trans.write(buff)
-
-  def writeString(self, str):
-    self.writeI32(len(str))
-    self.trans.write(str)
-
-  def readMessageBegin(self):
-    sz = self.readI32()
-    if sz < 0:
-      version = sz & TBinaryProtocol.VERSION_MASK
-      if version != TBinaryProtocol.VERSION_1:
-        raise TProtocolException(type=TProtocolException.BAD_VERSION, message='Bad version in readMessageBegin: %d' % (sz))
-      type = sz & TBinaryProtocol.TYPE_MASK
-      name = self.readString()
-      seqid = self.readI32()
-    else:
-      if self.strictRead:
-        raise TProtocolException(type=TProtocolException.BAD_VERSION, message='No protocol version header')
-      name = self.trans.readAll(sz)
-      type = self.readByte()
-      seqid = self.readI32()
-    return (name, type, seqid)
-
-  def readMessageEnd(self):
-    pass
-
-  def readStructBegin(self):
-    pass
-
-  def readStructEnd(self):
-    pass
-
-  def readFieldBegin(self):
-    type = self.readByte()
-    if type == TType.STOP:
-      return (None, type, 0)
-    id = self.readI16()
-    return (None, type, id)
-
-  def readFieldEnd(self):
-    pass
-
-  def readMapBegin(self):
-    ktype = self.readByte()
-    vtype = self.readByte()
-    size = self.readI32()
-    return (ktype, vtype, size)
-
-  def readMapEnd(self):
-    pass
-
-  def readListBegin(self):
-    etype = self.readByte()
-    size = self.readI32()
-    return (etype, size)
-
-  def readListEnd(self):
-    pass
-
-  def readSetBegin(self):
-    etype = self.readByte()
-    size = self.readI32()
-    return (etype, size)
-
-  def readSetEnd(self):
-    pass
-
-  def readBool(self):
-    byte = self.readByte()
-    if byte == 0:
-      return False
-    return True
-
-  def readByte(self):
-    buff = self.trans.readAll(1)
-    val, = unpack('!b', buff)
-    return val
-
-  def readI16(self):
-    buff = self.trans.readAll(2)
-    val, = unpack('!h', buff)
-    return val
-
-  def readI32(self):
-    buff = self.trans.readAll(4)
-    val, = unpack('!i', buff)
-    return val
-
-  def readI64(self):
-    buff = self.trans.readAll(8)
-    val, = unpack('!q', buff)
-    return val
-
-  def readDouble(self):
-    buff = self.trans.readAll(8)
-    val, = unpack('!d', buff)
-    return val
-
-  def readString(self):
-    len = self.readI32()
-    str = self.trans.readAll(len)
-    return str
-
-
-class TBinaryProtocolFactory:
-  def __init__(self, strictRead=False, strictWrite=True):
-    self.strictRead = strictRead
-    self.strictWrite = strictWrite
-
-  def getProtocol(self, trans):
-    prot = TBinaryProtocol(trans, self.strictRead, self.strictWrite)
-    return prot
-
-
-class TBinaryProtocolAccelerated(TBinaryProtocol):
-
-  """C-Accelerated version of TBinaryProtocol.
-
-  This class does not override any of TBinaryProtocol's methods,
-  but the generated code recognizes it directly and will call into
-  our C module to do the encoding, bypassing this object entirely.
-  We inherit from TBinaryProtocol so that the normal TBinaryProtocol
-  encoding can happen if the fastbinary module doesn't work for some
-  reason.  (TODO(dreiss): Make this happen sanely in more cases.)
-
-  In order to take advantage of the C module, just use
-  TBinaryProtocolAccelerated instead of TBinaryProtocol.
-
-  NOTE:  This code was contributed by an external developer.
-         The internal Thrift team has reviewed and tested it,
-         but we cannot guarantee that it is production-ready.
-         Please feel free to report bugs and/or success stories
-         to the public mailing list.
-  """
-
-  pass
-
-
-class TBinaryProtocolAcceleratedFactory:
-  def getProtocol(self, trans):
-    return TBinaryProtocolAccelerated(trans)
diff --git a/module/lib/thrift/protocol/TCompactProtocol.py b/module/lib/thrift/protocol/TCompactProtocol.py
deleted file mode 100644
index 016a33171..000000000
--- a/module/lib/thrift/protocol/TCompactProtocol.py
+++ /dev/null
@@ -1,395 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-from TProtocol import *
-from struct import pack, unpack
-
-__all__ = ['TCompactProtocol', 'TCompactProtocolFactory']
-
-CLEAR = 0
-FIELD_WRITE = 1
-VALUE_WRITE = 2
-CONTAINER_WRITE = 3
-BOOL_WRITE = 4
-FIELD_READ = 5
-CONTAINER_READ = 6
-VALUE_READ = 7
-BOOL_READ = 8
-
-def make_helper(v_from, container):
-  def helper(func):
-    def nested(self, *args, **kwargs):
-      assert self.state in (v_from, container), (self.state, v_from, container)
-      return func(self, *args, **kwargs)
-    return nested
-  return helper
-writer = make_helper(VALUE_WRITE, CONTAINER_WRITE)
-reader = make_helper(VALUE_READ, CONTAINER_READ)
-
-def makeZigZag(n, bits):
-  return (n << 1) ^ (n >> (bits - 1))
-
-def fromZigZag(n):
-  return (n >> 1) ^ -(n & 1)
-
-def writeVarint(trans, n):
-  out = []
-  while True:
-    if n & ~0x7f == 0:
-      out.append(n)
-      break
-    else:
-      out.append((n & 0xff) | 0x80)
-      n = n >> 7
-  trans.write(''.join(map(chr, out)))
-
-def readVarint(trans):
-  result = 0
-  shift = 0
-  while True:
-    x = trans.readAll(1)
-    byte = ord(x)
-    result |= (byte & 0x7f) << shift
-    if byte >> 7 == 0:
-      return result
-    shift += 7
-
-class CompactType:
-  STOP = 0x00
-  TRUE = 0x01
-  FALSE = 0x02
-  BYTE = 0x03
-  I16 = 0x04
-  I32 = 0x05
-  I64 = 0x06
-  DOUBLE = 0x07
-  BINARY = 0x08
-  LIST = 0x09
-  SET = 0x0A
-  MAP = 0x0B
-  STRUCT = 0x0C
-
-CTYPES = {TType.STOP: CompactType.STOP,
-          TType.BOOL: CompactType.TRUE, # used for collection
-          TType.BYTE: CompactType.BYTE,
-          TType.I16: CompactType.I16,
-          TType.I32: CompactType.I32,
-          TType.I64: CompactType.I64,
-          TType.DOUBLE: CompactType.DOUBLE,
-          TType.STRING: CompactType.BINARY,
-          TType.STRUCT: CompactType.STRUCT,
-          TType.LIST: CompactType.LIST,
-          TType.SET: CompactType.SET,
-          TType.MAP: CompactType.MAP
-          }
-
-TTYPES = {}
-for k, v in CTYPES.items():
-  TTYPES[v] = k
-TTYPES[CompactType.FALSE] = TType.BOOL
-del k
-del v
-
-class TCompactProtocol(TProtocolBase):
-  "Compact implementation of the Thrift protocol driver."
-
-  PROTOCOL_ID = 0x82
-  VERSION = 1
-  VERSION_MASK = 0x1f
-  TYPE_MASK = 0xe0
-  TYPE_SHIFT_AMOUNT = 5
-
-  def __init__(self, trans):
-    TProtocolBase.__init__(self, trans)
-    self.state = CLEAR
-    self.__last_fid = 0
-    self.__bool_fid = None
-    self.__bool_value = None
-    self.__structs = []
-    self.__containers = []
-
-  def __writeVarint(self, n):
-    writeVarint(self.trans, n)
-
-  def writeMessageBegin(self, name, type, seqid):
-    assert self.state == CLEAR
-    self.__writeUByte(self.PROTOCOL_ID)
-    self.__writeUByte(self.VERSION | (type << self.TYPE_SHIFT_AMOUNT))
-    self.__writeVarint(seqid)
-    self.__writeString(name)
-    self.state = VALUE_WRITE
-
-  def writeMessageEnd(self):
-    assert self.state == VALUE_WRITE
-    self.state = CLEAR
-
-  def writeStructBegin(self, name):
-    assert self.state in (CLEAR, CONTAINER_WRITE, VALUE_WRITE), self.state
-    self.__structs.append((self.state, self.__last_fid))
-    self.state = FIELD_WRITE
-    self.__last_fid = 0
-
-  def writeStructEnd(self):
-    assert self.state == FIELD_WRITE
-    self.state, self.__last_fid = self.__structs.pop()
-
-  def writeFieldStop(self):
-    self.__writeByte(0)
-
-  def __writeFieldHeader(self, type, fid):
-    delta = fid - self.__last_fid
-    if 0 < delta <= 15:
-      self.__writeUByte(delta << 4 | type)
-    else:
-      self.__writeByte(type)
-      self.__writeI16(fid)
-    self.__last_fid = fid
-
-  def writeFieldBegin(self, name, type, fid):
-    assert self.state == FIELD_WRITE, self.state
-    if type == TType.BOOL:
-      self.state = BOOL_WRITE
-      self.__bool_fid = fid
-    else:
-      self.state = VALUE_WRITE
-      self.__writeFieldHeader(CTYPES[type], fid)
-
-  def writeFieldEnd(self):
-    assert self.state in (VALUE_WRITE, BOOL_WRITE), self.state
-    self.state = FIELD_WRITE
-
-  def __writeUByte(self, byte):
-    self.trans.write(pack('!B', byte))
-
-  def __writeByte(self, byte):
-    self.trans.write(pack('!b', byte))
-
-  def __writeI16(self, i16):
-    self.__writeVarint(makeZigZag(i16, 16))
-
-  def __writeSize(self, i32):
-    self.__writeVarint(i32)
-
-  def writeCollectionBegin(self, etype, size):
-    assert self.state in (VALUE_WRITE, CONTAINER_WRITE), self.state
-    if size <= 14:
-      self.__writeUByte(size << 4 | CTYPES[etype])
-    else:
-      self.__writeUByte(0xf0 | CTYPES[etype])
-      self.__writeSize(size)
-    self.__containers.append(self.state)
-    self.state = CONTAINER_WRITE
-  writeSetBegin = writeCollectionBegin
-  writeListBegin = writeCollectionBegin
-
-  def writeMapBegin(self, ktype, vtype, size):
-    assert self.state in (VALUE_WRITE, CONTAINER_WRITE), self.state
-    if size == 0:
-      self.__writeByte(0)
-    else:
-      self.__writeSize(size)
-      self.__writeUByte(CTYPES[ktype] << 4 | CTYPES[vtype])
-    self.__containers.append(self.state)
-    self.state = CONTAINER_WRITE
-
-  def writeCollectionEnd(self):
-    assert self.state == CONTAINER_WRITE, self.state
-    self.state = self.__containers.pop()
-  writeMapEnd = writeCollectionEnd
-  writeSetEnd = writeCollectionEnd
-  writeListEnd = writeCollectionEnd
-
-  def writeBool(self, bool):
-    if self.state == BOOL_WRITE:
-        if bool:
-            ctype = CompactType.TRUE
-        else:
-            ctype = CompactType.FALSE
-        self.__writeFieldHeader(ctype, self.__bool_fid)
-    elif self.state == CONTAINER_WRITE:
-       if bool:
-           self.__writeByte(CompactType.TRUE)
-       else:
-           self.__writeByte(CompactType.FALSE)
-    else:
-      raise AssertionError, "Invalid state in compact protocol"
-
-  writeByte = writer(__writeByte)
-  writeI16 = writer(__writeI16)
-
-  @writer
-  def writeI32(self, i32):
-    self.__writeVarint(makeZigZag(i32, 32))
-
-  @writer
-  def writeI64(self, i64):
-    self.__writeVarint(makeZigZag(i64, 64))
-
-  @writer
-  def writeDouble(self, dub):
-    self.trans.write(pack('!d', dub))
-
-  def __writeString(self, s):
-    self.__writeSize(len(s))
-    self.trans.write(s)
-  writeString = writer(__writeString)
-
-  def readFieldBegin(self):
-    assert self.state == FIELD_READ, self.state
-    type = self.__readUByte()
-    if type & 0x0f == TType.STOP:
-      return (None, 0, 0)
-    delta = type >> 4
-    if delta == 0:
-      fid = self.__readI16()
-    else:
-      fid = self.__last_fid + delta
-    self.__last_fid = fid
-    type = type & 0x0f
-    if type == CompactType.TRUE:
-      self.state = BOOL_READ
-      self.__bool_value = True
-    elif type == CompactType.FALSE:
-      self.state = BOOL_READ
-      self.__bool_value = False
-    else:
-      self.state = VALUE_READ
-    return (None, self.__getTType(type), fid)
-
-  def readFieldEnd(self):
-    assert self.state in (VALUE_READ, BOOL_READ), self.state
-    self.state = FIELD_READ
-
-  def __readUByte(self):
-    result, = unpack('!B', self.trans.readAll(1))
-    return result
-
-  def __readByte(self):
-    result, = unpack('!b', self.trans.readAll(1))
-    return result
-
-  def __readVarint(self):
-    return readVarint(self.trans)
-
-  def __readZigZag(self):
-    return fromZigZag(self.__readVarint())
-
-  def __readSize(self):
-    result = self.__readVarint()
-    if result < 0:
-      raise TException("Length < 0")
-    return result
-
-  def readMessageBegin(self):
-    assert self.state == CLEAR
-    proto_id = self.__readUByte()
-    if proto_id != self.PROTOCOL_ID:
-      raise TProtocolException(TProtocolException.BAD_VERSION,
-          'Bad protocol id in the message: %d' % proto_id)
-    ver_type = self.__readUByte()
-    type = (ver_type & self.TYPE_MASK) >> self.TYPE_SHIFT_AMOUNT
-    version = ver_type & self.VERSION_MASK
-    if version != self.VERSION:
-      raise TProtocolException(TProtocolException.BAD_VERSION,
-          'Bad version: %d (expect %d)' % (version, self.VERSION))
-    seqid = self.__readVarint()
-    name = self.__readString()
-    return (name, type, seqid)
-
-  def readMessageEnd(self):
-    assert self.state == CLEAR
-    assert len(self.__structs) == 0
-
-  def readStructBegin(self):
-    assert self.state in (CLEAR, CONTAINER_READ, VALUE_READ), self.state
-    self.__structs.append((self.state, self.__last_fid))
-    self.state = FIELD_READ
-    self.__last_fid = 0
-
-  def readStructEnd(self):
-    assert self.state == FIELD_READ
-    self.state, self.__last_fid = self.__structs.pop()
-
-  def readCollectionBegin(self):
-    assert self.state in (VALUE_READ, CONTAINER_READ), self.state
-    size_type = self.__readUByte()
-    size = size_type >> 4
-    type = self.__getTType(size_type)
-    if size == 15:
-      size = self.__readSize()
-    self.__containers.append(self.state)
-    self.state = CONTAINER_READ
-    return type, size
-  readSetBegin = readCollectionBegin
-  readListBegin = readCollectionBegin
-
-  def readMapBegin(self):
-    assert self.state in (VALUE_READ, CONTAINER_READ), self.state
-    size = self.__readSize()
-    types = 0
-    if size > 0:
-      types = self.__readUByte()
-    vtype = self.__getTType(types)
-    ktype = self.__getTType(types >> 4)
-    self.__containers.append(self.state)
-    self.state = CONTAINER_READ
-    return (ktype, vtype, size)
-
-  def readCollectionEnd(self):
-    assert self.state == CONTAINER_READ, self.state
-    self.state = self.__containers.pop()
-  readSetEnd = readCollectionEnd
-  readListEnd = readCollectionEnd
-  readMapEnd = readCollectionEnd
-
-  def readBool(self):
-    if self.state == BOOL_READ:
-      return self.__bool_value == CompactType.TRUE
-    elif self.state == CONTAINER_READ:
-      return self.__readByte() == CompactType.TRUE
-    else:
-      raise AssertionError, "Invalid state in compact protocol: %d" % self.state
-
-  readByte = reader(__readByte)
-  __readI16 = __readZigZag
-  readI16 = reader(__readZigZag)
-  readI32 = reader(__readZigZag)
-  readI64 = reader(__readZigZag)
-
-  @reader
-  def readDouble(self):
-    buff = self.trans.readAll(8)
-    val, = unpack('!d', buff)
-    return val
-
-  def __readString(self):
-    len = self.__readSize()
-    return self.trans.readAll(len)
-  readString = reader(__readString)
-
-  def __getTType(self, byte):
-    return TTYPES[byte & 0x0f]
-
-
-class TCompactProtocolFactory:
-  def __init__(self):
-    pass
-
-  def getProtocol(self, trans):
-    return TCompactProtocol(trans)
diff --git a/module/lib/thrift/protocol/TProtocol.py b/module/lib/thrift/protocol/TProtocol.py
deleted file mode 100644
index 7338ff68a..000000000
--- a/module/lib/thrift/protocol/TProtocol.py
+++ /dev/null
@@ -1,404 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-from thrift.Thrift import *
-
-class TProtocolException(TException):
-
-  """Custom Protocol Exception class"""
-
-  UNKNOWN = 0
-  INVALID_DATA = 1
-  NEGATIVE_SIZE = 2
-  SIZE_LIMIT = 3
-  BAD_VERSION = 4
-
-  def __init__(self, type=UNKNOWN, message=None):
-    TException.__init__(self, message)
-    self.type = type
-
-class TProtocolBase:
-
-  """Base class for Thrift protocol driver."""
-
-  def __init__(self, trans):
-    self.trans = trans
-
-  def writeMessageBegin(self, name, type, seqid):
-    pass
-
-  def writeMessageEnd(self):
-    pass
-
-  def writeStructBegin(self, name):
-    pass
-
-  def writeStructEnd(self):
-    pass
-
-  def writeFieldBegin(self, name, type, id):
-    pass
-
-  def writeFieldEnd(self):
-    pass
-
-  def writeFieldStop(self):
-    pass
-
-  def writeMapBegin(self, ktype, vtype, size):
-    pass
-
-  def writeMapEnd(self):
-    pass
-
-  def writeListBegin(self, etype, size):
-    pass
-
-  def writeListEnd(self):
-    pass
-
-  def writeSetBegin(self, etype, size):
-    pass
-
-  def writeSetEnd(self):
-    pass
-
-  def writeBool(self, bool):
-    pass
-
-  def writeByte(self, byte):
-    pass
-
-  def writeI16(self, i16):
-    pass
-
-  def writeI32(self, i32):
-    pass
-
-  def writeI64(self, i64):
-    pass
-
-  def writeDouble(self, dub):
-    pass
-
-  def writeString(self, str):
-    pass
-
-  def readMessageBegin(self):
-    pass
-
-  def readMessageEnd(self):
-    pass
-
-  def readStructBegin(self):
-    pass
-
-  def readStructEnd(self):
-    pass
-
-  def readFieldBegin(self):
-    pass
-
-  def readFieldEnd(self):
-    pass
-
-  def readMapBegin(self):
-    pass
-
-  def readMapEnd(self):
-    pass
-
-  def readListBegin(self):
-    pass
-
-  def readListEnd(self):
-    pass
-
-  def readSetBegin(self):
-    pass
-
-  def readSetEnd(self):
-    pass
-
-  def readBool(self):
-    pass
-
-  def readByte(self):
-    pass
-
-  def readI16(self):
-    pass
-
-  def readI32(self):
-    pass
-
-  def readI64(self):
-    pass
-
-  def readDouble(self):
-    pass
-
-  def readString(self):
-    pass
-
-  def skip(self, type):
-    if type == TType.STOP:
-      return
-    elif type == TType.BOOL:
-      self.readBool()
-    elif type == TType.BYTE:
-      self.readByte()
-    elif type == TType.I16:
-      self.readI16()
-    elif type == TType.I32:
-      self.readI32()
-    elif type == TType.I64:
-      self.readI64()
-    elif type == TType.DOUBLE:
-      self.readDouble()
-    elif type == TType.STRING:
-      self.readString()
-    elif type == TType.STRUCT:
-      name = self.readStructBegin()
-      while True:
-        (name, type, id) = self.readFieldBegin()
-        if type == TType.STOP:
-          break
-        self.skip(type)
-        self.readFieldEnd()
-      self.readStructEnd()
-    elif type == TType.MAP:
-      (ktype, vtype, size) = self.readMapBegin()
-      for i in range(size):
-        self.skip(ktype)
-        self.skip(vtype)
-      self.readMapEnd()
-    elif type == TType.SET:
-      (etype, size) = self.readSetBegin()
-      for i in range(size):
-        self.skip(etype)
-      self.readSetEnd()
-    elif type == TType.LIST:
-      (etype, size) = self.readListBegin()
-      for i in range(size):
-        self.skip(etype)
-      self.readListEnd()
-
-  # tuple of: ( 'reader method' name, is_container boolean, 'writer_method' name )
-  _TTYPE_HANDLERS = (
-       (None, None, False), # 0 == TType,STOP
-       (None, None, False), # 1 == TType.VOID # TODO: handle void?
-       ('readBool', 'writeBool', False), # 2 == TType.BOOL
-       ('readByte',  'writeByte', False), # 3 == TType.BYTE and I08
-       ('readDouble', 'writeDouble', False), # 4 == TType.DOUBLE
-       (None, None, False), # 5, undefined
-       ('readI16', 'writeI16', False), # 6 == TType.I16
-       (None, None, False), # 7, undefined
-       ('readI32', 'writeI32', False), # 8 == TType.I32
-       (None, None, False), # 9, undefined
-       ('readI64', 'writeI64', False), # 10 == TType.I64
-       ('readString', 'writeString', False), # 11 == TType.STRING and UTF7
-       ('readContainerStruct', 'writeContainerStruct', True), # 12 == TType.STRUCT
-       ('readContainerMap', 'writeContainerMap', True), # 13 == TType.MAP
-       ('readContainerSet', 'writeContainerSet', True), # 14 == TType.SET
-       ('readContainerList', 'writeContainerList', True), # 15 == TType.LIST
-       (None, None, False), # 16 == TType.UTF8 # TODO: handle utf8 types?
-       (None, None, False)# 17 == TType.UTF16 # TODO: handle utf16 types?
-      )
-
-  def readFieldByTType(self, ttype, spec):
-    try:
-      (r_handler, w_handler, is_container) = self._TTYPE_HANDLERS[ttype]
-    except IndexError:
-      raise TProtocolException(type=TProtocolException.INVALID_DATA,
-                               message='Invalid field type %d' % (ttype))
-    if r_handler is None:
-      raise TProtocolException(type=TProtocolException.INVALID_DATA,
-                               message='Invalid field type %d' % (ttype))
-    reader = getattr(self, r_handler)
-    if not is_container:
-      return reader()
-    return reader(spec)
-
-  def readContainerList(self, spec):
-    results = []
-    ttype, tspec = spec[0], spec[1]
-    r_handler = self._TTYPE_HANDLERS[ttype][0]
-    reader = getattr(self, r_handler)
-    (list_type, list_len) = self.readListBegin()
-    if tspec is None:
-      # list values are simple types
-      for idx in xrange(list_len):
-        results.append(reader())
-    else:
-      # this is like an inlined readFieldByTType
-      container_reader = self._TTYPE_HANDLERS[list_type][0]
-      val_reader = getattr(self, container_reader)
-      for idx in xrange(list_len):
-        val = val_reader(tspec)
-        results.append(val)
-    self.readListEnd()
-    return results
-
-  def readContainerSet(self, spec):
-    results = set()
-    ttype, tspec = spec[0], spec[1]
-    r_handler = self._TTYPE_HANDLERS[ttype][0]
-    reader = getattr(self, r_handler)
-    (set_type, set_len) = self.readSetBegin()
-    if tspec is None:
-      # set members are simple types
-      for idx in xrange(set_len):
-        results.add(reader())
-    else:
-      container_reader = self._TTYPE_HANDLERS[set_type][0]
-      val_reader = getattr(self, container_reader)
-      for idx in xrange(set_len):
-        results.add(val_reader(tspec)) 
-    self.readSetEnd()
-    return results
-
-  def readContainerStruct(self, spec):
-    (obj_class, obj_spec) = spec
-    obj = obj_class()
-    obj.read(self)
-    return obj
-  
-  def readContainerMap(self, spec):
-    results = dict()
-    key_ttype, key_spec = spec[0], spec[1]
-    val_ttype, val_spec = spec[2], spec[3]
-    (map_ktype, map_vtype, map_len) = self.readMapBegin()
-    # TODO: compare types we just decoded with thrift_spec and abort/skip if types disagree
-    key_reader = getattr(self, self._TTYPE_HANDLERS[key_ttype][0])
-    val_reader = getattr(self, self._TTYPE_HANDLERS[val_ttype][0])
-    # list values are simple types
-    for idx in xrange(map_len):
-      if key_spec is None:
-        k_val = key_reader()
-      else:
-        k_val = self.readFieldByTType(key_ttype, key_spec)
-      if val_spec is None:
-        v_val = val_reader()
-      else:
-        v_val = self.readFieldByTType(val_ttype, val_spec)
-      # this raises a TypeError with unhashable keys types. i.e. d=dict(); d[[0,1]] = 2 fails
-      results[k_val] = v_val
-    self.readMapEnd()
-    return results
-
-  def readStruct(self, obj, thrift_spec):
-    self.readStructBegin()
-    while True:
-      (fname, ftype, fid) = self.readFieldBegin()
-      if ftype == TType.STOP:
-        break
-      try:
-        field = thrift_spec[fid]
-      except IndexError:
-        self.skip(ftype)
-      else:
-        if field is not None and ftype == field[1]:
-          fname = field[2]
-          fspec = field[3]
-          val = self.readFieldByTType(ftype, fspec)
-          setattr(obj, fname, val)
-        else:
-          self.skip(ftype)
-      self.readFieldEnd()
-    self.readStructEnd()
-
-  def writeContainerStruct(self, val, spec):
-    val.write(self)
-
-  def writeContainerList(self, val, spec):
-    self.writeListBegin(spec[0], len(val))
-    r_handler, w_handler, is_container  = self._TTYPE_HANDLERS[spec[0]]
-    e_writer = getattr(self, w_handler)
-    if not is_container:
-      for elem in val:
-        e_writer(elem)
-    else:
-      for elem in val:
-        e_writer(elem, spec[1])
-    self.writeListEnd()
-
-  def writeContainerSet(self, val, spec):
-    self.writeSetBegin(spec[0], len(val))
-    r_handler, w_handler, is_container = self._TTYPE_HANDLERS[spec[0]]
-    e_writer = getattr(self, w_handler)
-    if not is_container:
-      for elem in val:
-        e_writer(elem)
-    else:
-      for elem in val:
-        e_writer(elem, spec[1])
-    self.writeSetEnd()
-
-  def writeContainerMap(self, val, spec):
-    k_type = spec[0]
-    v_type = spec[2]
-    ignore, ktype_name, k_is_container = self._TTYPE_HANDLERS[k_type]
-    ignore, vtype_name, v_is_container = self._TTYPE_HANDLERS[v_type]
-    k_writer = getattr(self, ktype_name)
-    v_writer = getattr(self, vtype_name)
-    self.writeMapBegin(k_type, v_type, len(val))
-    for m_key, m_val in val.iteritems():
-      if not k_is_container:
-        k_writer(m_key)
-      else:
-        k_writer(m_key, spec[1])
-      if not v_is_container:
-        v_writer(m_val)
-      else:
-        v_writer(m_val, spec[3])
-    self.writeMapEnd()
-
-  def writeStruct(self, obj, thrift_spec):
-    self.writeStructBegin(obj.__class__.__name__)
-    for field in thrift_spec:
-      if field is None:
-        continue
-      fname = field[2]
-      val = getattr(obj, fname)
-      if val is None:
-        # skip writing out unset fields
-        continue
-      fid = field[0]
-      ftype = field[1]
-      fspec = field[3]
-      # get the writer method for this value
-      self.writeFieldBegin(fname, ftype, fid)
-      self.writeFieldByTType(ftype, val, fspec)
-      self.writeFieldEnd()
-    self.writeFieldStop()
-    self.writeStructEnd()
-
-  def writeFieldByTType(self, ttype, val, spec):
-    r_handler, w_handler, is_container = self._TTYPE_HANDLERS[ttype]
-    writer = getattr(self, w_handler)
-    if is_container:
-      writer(val, spec)
-    else:
-      writer(val)
-
-class TProtocolFactory:
-  def getProtocol(self, trans):
-    pass
-
diff --git a/module/lib/thrift/protocol/__init__.py b/module/lib/thrift/protocol/__init__.py
deleted file mode 100644
index d53359b28..000000000
--- a/module/lib/thrift/protocol/__init__.py
+++ /dev/null
@@ -1,20 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-__all__ = ['TProtocol', 'TBinaryProtocol', 'fastbinary', 'TBase']
diff --git a/module/lib/thrift/server/THttpServer.py b/module/lib/thrift/server/THttpServer.py
deleted file mode 100644
index 3047d9c00..000000000
--- a/module/lib/thrift/server/THttpServer.py
+++ /dev/null
@@ -1,82 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-import BaseHTTPServer
-
-from thrift.server import TServer
-from thrift.transport import TTransport
-
-class ResponseException(Exception):
-  """Allows handlers to override the HTTP response
-
-  Normally, THttpServer always sends a 200 response.  If a handler wants
-  to override this behavior (e.g., to simulate a misconfigured or
-  overloaded web server during testing), it can raise a ResponseException.
-  The function passed to the constructor will be called with the
-  RequestHandler as its only argument.
-  """
-  def __init__(self, handler):
-    self.handler = handler
-
-
-class THttpServer(TServer.TServer):
-  """A simple HTTP-based Thrift server
-
-  This class is not very performant, but it is useful (for example) for
-  acting as a mock version of an Apache-based PHP Thrift endpoint."""
-
-  def __init__(self, processor, server_address,
-      inputProtocolFactory, outputProtocolFactory = None,
-      server_class = BaseHTTPServer.HTTPServer):
-    """Set up protocol factories and HTTP server.
-
-    See BaseHTTPServer for server_address.
-    See TServer for protocol factories."""
-
-    if outputProtocolFactory is None:
-      outputProtocolFactory = inputProtocolFactory
-
-    TServer.TServer.__init__(self, processor, None, None, None,
-        inputProtocolFactory, outputProtocolFactory)
-
-    thttpserver = self
-
-    class RequestHander(BaseHTTPServer.BaseHTTPRequestHandler):
-      def do_POST(self):
-        # Don't care about the request path.
-        itrans = TTransport.TFileObjectTransport(self.rfile)
-        otrans = TTransport.TFileObjectTransport(self.wfile)
-        itrans = TTransport.TBufferedTransport(itrans, int(self.headers['Content-Length']))
-        otrans = TTransport.TMemoryBuffer()
-        iprot = thttpserver.inputProtocolFactory.getProtocol(itrans)
-        oprot = thttpserver.outputProtocolFactory.getProtocol(otrans)
-        try:
-          thttpserver.processor.process(iprot, oprot)
-        except ResponseException, exn:
-          exn.handler(self)
-        else:
-          self.send_response(200)
-          self.send_header("content-type", "application/x-thrift")
-          self.end_headers()
-          self.wfile.write(otrans.getvalue())
-
-    self.httpd = server_class(server_address, RequestHander)
-
-  def serve(self):
-    self.httpd.serve_forever()
diff --git a/module/lib/thrift/server/TNonblockingServer.py b/module/lib/thrift/server/TNonblockingServer.py
deleted file mode 100644
index ea348a0b6..000000000
--- a/module/lib/thrift/server/TNonblockingServer.py
+++ /dev/null
@@ -1,310 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-"""Implementation of non-blocking server.
-
-The main idea of the server is reciving and sending requests
-only from main thread.
-
-It also makes thread pool server in tasks terms, not connections.
-"""
-import threading
-import socket
-import Queue
-import select
-import struct
-import logging
-
-from thrift.transport import TTransport
-from thrift.protocol.TBinaryProtocol import TBinaryProtocolFactory
-
-__all__ = ['TNonblockingServer']
-
-class Worker(threading.Thread):
-    """Worker is a small helper to process incoming connection."""
-    def __init__(self, queue):
-        threading.Thread.__init__(self)
-        self.queue = queue
-
-    def run(self):
-        """Process queries from task queue, stop if processor is None."""
-        while True:
-            try:
-                processor, iprot, oprot, otrans, callback = self.queue.get()
-                if processor is None:
-                    break
-                processor.process(iprot, oprot)
-                callback(True, otrans.getvalue())
-            except Exception:
-                logging.exception("Exception while processing request")
-                callback(False, '')
-
-WAIT_LEN = 0
-WAIT_MESSAGE = 1
-WAIT_PROCESS = 2
-SEND_ANSWER = 3
-CLOSED = 4
-
-def locked(func):
-    "Decorator which locks self.lock."
-    def nested(self, *args, **kwargs):
-        self.lock.acquire()
-        try:
-            return func(self, *args, **kwargs)
-        finally:
-            self.lock.release()
-    return nested
-
-def socket_exception(func):
-    "Decorator close object on socket.error."
-    def read(self, *args, **kwargs):
-        try:
-            return func(self, *args, **kwargs)
-        except socket.error:
-            self.close()
-    return read
-
-class Connection:
-    """Basic class is represented connection.
-    
-    It can be in state:
-        WAIT_LEN --- connection is reading request len.
-        WAIT_MESSAGE --- connection is reading request.
-        WAIT_PROCESS --- connection has just read whole request and 
-            waits for call ready routine.
-        SEND_ANSWER --- connection is sending answer string (including length
-            of answer).
-        CLOSED --- socket was closed and connection should be deleted.
-    """
-    def __init__(self, new_socket, wake_up):
-        self.socket = new_socket
-        self.socket.setblocking(False)
-        self.status = WAIT_LEN
-        self.len = 0
-        self.message = ''
-        self.lock = threading.Lock()
-        self.wake_up = wake_up
-
-    def _read_len(self):
-        """Reads length of request.
-        
-        It's really paranoic routine and it may be replaced by 
-        self.socket.recv(4)."""
-        read = self.socket.recv(4 - len(self.message))
-        if len(read) == 0:
-            # if we read 0 bytes and self.message is empty, it means client close 
-            # connection
-            if len(self.message) != 0:
-                logging.error("can't read frame size from socket")
-            self.close()
-            return
-        self.message += read
-        if len(self.message) == 4:
-            self.len, = struct.unpack('!i', self.message)
-            if self.len < 0:
-                logging.error("negative frame size, it seems client"\
-                    " doesn't use FramedTransport")
-                self.close()
-            elif self.len == 0:
-                logging.error("empty frame, it's really strange")
-                self.close()
-            else:
-                self.message = ''
-                self.status = WAIT_MESSAGE
-
-    @socket_exception
-    def read(self):
-        """Reads data from stream and switch state."""
-        assert self.status in (WAIT_LEN, WAIT_MESSAGE)
-        if self.status == WAIT_LEN:
-            self._read_len()
-            # go back to the main loop here for simplicity instead of
-            # falling through, even though there is a good chance that
-            # the message is already available
-        elif self.status == WAIT_MESSAGE:
-            read = self.socket.recv(self.len - len(self.message))
-            if len(read) == 0:
-                logging.error("can't read frame from socket (get %d of %d bytes)" %
-                    (len(self.message), self.len))
-                self.close()
-                return
-            self.message += read
-            if len(self.message) == self.len:
-                self.status = WAIT_PROCESS
-
-    @socket_exception
-    def write(self):
-        """Writes data from socket and switch state."""
-        assert self.status == SEND_ANSWER
-        sent = self.socket.send(self.message)
-        if sent == len(self.message):
-            self.status = WAIT_LEN
-            self.message = ''
-            self.len = 0
-        else:
-            self.message = self.message[sent:]
-
-    @locked
-    def ready(self, all_ok, message):
-        """Callback function for switching state and waking up main thread.
-        
-        This function is the only function witch can be called asynchronous.
-        
-        The ready can switch Connection to three states:
-            WAIT_LEN if request was oneway.
-            SEND_ANSWER if request was processed in normal way.
-            CLOSED if request throws unexpected exception.
-        
-        The one wakes up main thread.
-        """
-        assert self.status == WAIT_PROCESS
-        if not all_ok:
-            self.close()
-            self.wake_up()
-            return
-        self.len = ''
-        if len(message) == 0:
-            # it was a oneway request, do not write answer
-            self.message = ''
-            self.status = WAIT_LEN
-        else:
-            self.message = struct.pack('!i', len(message)) + message
-            self.status = SEND_ANSWER
-        self.wake_up()
-
-    @locked
-    def is_writeable(self):
-        "Returns True if connection should be added to write list of select."
-        return self.status == SEND_ANSWER
-
-    # it's not necessary, but...
-    @locked
-    def is_readable(self):
-        "Returns True if connection should be added to read list of select."
-        return self.status in (WAIT_LEN, WAIT_MESSAGE)
-
-    @locked
-    def is_closed(self):
-        "Returns True if connection is closed."
-        return self.status == CLOSED
-
-    def fileno(self):
-        "Returns the file descriptor of the associated socket."
-        return self.socket.fileno()
-
-    def close(self):
-        "Closes connection"
-        self.status = CLOSED
-        self.socket.close()
-
-class TNonblockingServer:
-    """Non-blocking server."""
-    def __init__(self, processor, lsocket, inputProtocolFactory=None, 
-            outputProtocolFactory=None, threads=10):
-        self.processor = processor
-        self.socket = lsocket
-        self.in_protocol = inputProtocolFactory or TBinaryProtocolFactory()
-        self.out_protocol = outputProtocolFactory or self.in_protocol
-        self.threads = int(threads)
-        self.clients = {}
-        self.tasks = Queue.Queue()
-        self._read, self._write = socket.socketpair()
-        self.prepared = False
-
-    def setNumThreads(self, num):
-        """Set the number of worker threads that should be created."""
-        # implement ThreadPool interface
-        assert not self.prepared, "You can't change number of threads for working server"
-        self.threads = num
-
-    def prepare(self):
-        """Prepares server for serve requests."""
-        self.socket.listen()
-        for _ in xrange(self.threads):
-            thread = Worker(self.tasks)
-            thread.setDaemon(True)
-            thread.start()
-        self.prepared = True
-
-    def wake_up(self):
-        """Wake up main thread.
-        
-        The server usualy waits in select call in we should terminate one.
-        The simplest way is using socketpair.
-        
-        Select always wait to read from the first socket of socketpair.
-        
-        In this case, we can just write anything to the second socket from
-        socketpair."""
-        self._write.send('1')
-
-    def _select(self):
-        """Does select on open connections."""
-        readable = [self.socket.handle.fileno(), self._read.fileno()]
-        writable = []
-        for i, connection in self.clients.items():
-            if connection.is_readable():
-                readable.append(connection.fileno())
-            if connection.is_writeable():
-                writable.append(connection.fileno())
-            if connection.is_closed():
-                del self.clients[i]
-        return select.select(readable, writable, readable)
-        
-    def handle(self):
-        """Handle requests.
-       
-        WARNING! You must call prepare BEFORE calling handle.
-        """
-        assert self.prepared, "You have to call prepare before handle"
-        rset, wset, xset = self._select()
-        for readable in rset:
-            if readable == self._read.fileno():
-                # don't care i just need to clean readable flag
-                self._read.recv(1024) 
-            elif readable == self.socket.handle.fileno():
-                client = self.socket.accept().handle
-                self.clients[client.fileno()] = Connection(client, self.wake_up)
-            else:
-                connection = self.clients[readable]
-                connection.read()
-                if connection.status == WAIT_PROCESS:
-                    itransport = TTransport.TMemoryBuffer(connection.message)
-                    otransport = TTransport.TMemoryBuffer()
-                    iprot = self.in_protocol.getProtocol(itransport)
-                    oprot = self.out_protocol.getProtocol(otransport)
-                    self.tasks.put([self.processor, iprot, oprot, 
-                                    otransport, connection.ready])
-        for writeable in wset:
-            self.clients[writeable].write()
-        for oob in xset:
-            self.clients[oob].close()
-            del self.clients[oob]
-
-    def close(self):
-        """Closes the server."""
-        for _ in xrange(self.threads):
-            self.tasks.put([None, None, None, None, None])
-        self.socket.close()
-        self.prepared = False
-        
-    def serve(self):
-        """Serve forever."""
-        self.prepare()
-        while True:
-            self.handle()
diff --git a/module/lib/thrift/server/TProcessPoolServer.py b/module/lib/thrift/server/TProcessPoolServer.py
deleted file mode 100644
index 7ed814a88..000000000
--- a/module/lib/thrift/server/TProcessPoolServer.py
+++ /dev/null
@@ -1,125 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-
-import logging
-from multiprocessing import  Process, Value, Condition, reduction
-
-from TServer import TServer
-from thrift.transport.TTransport import TTransportException
-
-class TProcessPoolServer(TServer):
-
-    """
-    Server with a fixed size pool of worker subprocesses which service requests.
-    Note that if you need shared state between the handlers - it's up to you!
-    Written by Dvir Volk, doat.com
-    """
-
-    def __init__(self, * args):
-        TServer.__init__(self, *args)
-        self.numWorkers = 10
-        self.workers = []
-        self.isRunning = Value('b', False)
-        self.stopCondition = Condition()
-        self.postForkCallback = None
-
-    def setPostForkCallback(self, callback):
-        if not callable(callback):
-            raise TypeError("This is not a callback!")
-        self.postForkCallback = callback
-
-    def setNumWorkers(self, num):
-        """Set the number of worker threads that should be created"""
-        self.numWorkers = num
-
-    def workerProcess(self):
-        """Loop around getting clients from the shared queue and process them."""
-
-        if self.postForkCallback:
-            self.postForkCallback()
-
-        while self.isRunning.value == True:
-            try:
-                client = self.serverTransport.accept()
-                self.serveClient(client)
-            except (KeyboardInterrupt, SystemExit):
-                return 0
-            except Exception, x:
-                logging.exception(x)
-
-    def serveClient(self, client):
-        """Process input/output from a client for as long as possible"""
-        itrans = self.inputTransportFactory.getTransport(client)
-        otrans = self.outputTransportFactory.getTransport(client)
-        iprot = self.inputProtocolFactory.getProtocol(itrans)
-        oprot = self.outputProtocolFactory.getProtocol(otrans)
-
-        try:
-            while True:
-                self.processor.process(iprot, oprot)
-        except TTransportException, tx:
-            pass
-        except Exception, x:
-            logging.exception(x)
-
-        itrans.close()
-        otrans.close()
-
-
-    def serve(self):
-        """Start a fixed number of worker threads and put client into a queue"""
-
-        #this is a shared state that can tell the workers to exit when set as false
-        self.isRunning.value = True
-
-        #first bind and listen to the port
-        self.serverTransport.listen()
-
-        #fork the children
-        for i in range(self.numWorkers):
-            try:
-                w = Process(target=self.workerProcess)
-                w.daemon = True
-                w.start()
-                self.workers.append(w)
-            except Exception, x:
-                logging.exception(x)
-
-        #wait until the condition is set by stop()
-
-        while True:
-
-            self.stopCondition.acquire()
-            try:
-                self.stopCondition.wait()
-                break
-            except (SystemExit, KeyboardInterrupt):
-		break
-            except Exception, x:
-                logging.exception(x)
-
-        self.isRunning.value = False
-
-    def stop(self):
-        self.isRunning.value = False
-        self.stopCondition.acquire()
-        self.stopCondition.notify()
-        self.stopCondition.release()
-
diff --git a/module/lib/thrift/server/TServer.py b/module/lib/thrift/server/TServer.py
deleted file mode 100644
index 8456e2d40..000000000
--- a/module/lib/thrift/server/TServer.py
+++ /dev/null
@@ -1,274 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-import logging
-import sys
-import os
-import traceback
-import threading
-import Queue
-
-from thrift.Thrift import TProcessor
-from thrift.transport import TTransport
-from thrift.protocol import TBinaryProtocol
-
-class TServer:
-
-  """Base interface for a server, which must have a serve method."""
-
-  """ 3 constructors for all servers:
-  1) (processor, serverTransport)
-  2) (processor, serverTransport, transportFactory, protocolFactory)
-  3) (processor, serverTransport,
-      inputTransportFactory, outputTransportFactory,
-      inputProtocolFactory, outputProtocolFactory)"""
-  def __init__(self, *args):
-    if (len(args) == 2):
-      self.__initArgs__(args[0], args[1],
-                        TTransport.TTransportFactoryBase(),
-                        TTransport.TTransportFactoryBase(),
-                        TBinaryProtocol.TBinaryProtocolFactory(),
-                        TBinaryProtocol.TBinaryProtocolFactory())
-    elif (len(args) == 4):
-      self.__initArgs__(args[0], args[1], args[2], args[2], args[3], args[3])
-    elif (len(args) == 6):
-      self.__initArgs__(args[0], args[1], args[2], args[3], args[4], args[5])
-
-  def __initArgs__(self, processor, serverTransport,
-                   inputTransportFactory, outputTransportFactory,
-                   inputProtocolFactory, outputProtocolFactory):
-    self.processor = processor
-    self.serverTransport = serverTransport
-    self.inputTransportFactory = inputTransportFactory
-    self.outputTransportFactory = outputTransportFactory
-    self.inputProtocolFactory = inputProtocolFactory
-    self.outputProtocolFactory = outputProtocolFactory
-
-  def serve(self):
-    pass
-
-class TSimpleServer(TServer):
-
-  """Simple single-threaded server that just pumps around one transport."""
-
-  def __init__(self, *args):
-    TServer.__init__(self, *args)
-
-  def serve(self):
-    self.serverTransport.listen()
-    while True:
-      client = self.serverTransport.accept()
-      itrans = self.inputTransportFactory.getTransport(client)
-      otrans = self.outputTransportFactory.getTransport(client)
-      iprot = self.inputProtocolFactory.getProtocol(itrans)
-      oprot = self.outputProtocolFactory.getProtocol(otrans)
-      try:
-        while True:
-          self.processor.process(iprot, oprot)
-      except TTransport.TTransportException, tx:
-        pass
-      except Exception, x:
-        logging.exception(x)
-
-      itrans.close()
-      otrans.close()
-
-class TThreadedServer(TServer):
-
-  """Threaded server that spawns a new thread per each connection."""
-
-  def __init__(self, *args, **kwargs):
-    TServer.__init__(self, *args)
-    self.daemon = kwargs.get("daemon", False)
-
-  def serve(self):
-    self.serverTransport.listen()
-    while True:
-      try:
-        client = self.serverTransport.accept()
-        t = threading.Thread(target = self.handle, args=(client,))
-        t.setDaemon(self.daemon)
-        t.start()
-      except KeyboardInterrupt:
-        raise
-      except Exception, x:
-        logging.exception(x)
-
-  def handle(self, client):
-    itrans = self.inputTransportFactory.getTransport(client)
-    otrans = self.outputTransportFactory.getTransport(client)
-    iprot = self.inputProtocolFactory.getProtocol(itrans)
-    oprot = self.outputProtocolFactory.getProtocol(otrans)
-    try:
-      while True:
-        self.processor.process(iprot, oprot)
-    except TTransport.TTransportException, tx:
-      pass
-    except Exception, x:
-      logging.exception(x)
-
-    itrans.close()
-    otrans.close()
-
-class TThreadPoolServer(TServer):
-
-  """Server with a fixed size pool of threads which service requests."""
-
-  def __init__(self, *args, **kwargs):
-    TServer.__init__(self, *args)
-    self.clients = Queue.Queue()
-    self.threads = 10
-    self.daemon = kwargs.get("daemon", False)
-
-  def setNumThreads(self, num):
-    """Set the number of worker threads that should be created"""
-    self.threads = num
-
-  def serveThread(self):
-    """Loop around getting clients from the shared queue and process them."""
-    while True:
-      try:
-        client = self.clients.get()
-        self.serveClient(client)
-      except Exception, x:
-        logging.exception(x)
-
-  def serveClient(self, client):
-    """Process input/output from a client for as long as possible"""
-    itrans = self.inputTransportFactory.getTransport(client)
-    otrans = self.outputTransportFactory.getTransport(client)
-    iprot = self.inputProtocolFactory.getProtocol(itrans)
-    oprot = self.outputProtocolFactory.getProtocol(otrans)
-    try:
-      while True:
-        self.processor.process(iprot, oprot)
-    except TTransport.TTransportException, tx:
-      pass
-    except Exception, x:
-      logging.exception(x)
-
-    itrans.close()
-    otrans.close()
-
-  def serve(self):
-    """Start a fixed number of worker threads and put client into a queue"""
-    for i in range(self.threads):
-      try:
-        t = threading.Thread(target = self.serveThread)
-        t.setDaemon(self.daemon)
-        t.start()
-      except Exception, x:
-        logging.exception(x)
-
-    # Pump the socket for clients
-    self.serverTransport.listen()
-    while True:
-      try:
-        client = self.serverTransport.accept()
-        self.clients.put(client)
-      except Exception, x:
-        logging.exception(x)
-
-
-class TForkingServer(TServer):
-
-  """A Thrift server that forks a new process for each request"""
-  """
-  This is more scalable than the threaded server as it does not cause
-  GIL contention.
-
-  Note that this has different semantics from the threading server.
-  Specifically, updates to shared variables will no longer be shared.
-  It will also not work on windows.
-
-  This code is heavily inspired by SocketServer.ForkingMixIn in the
-  Python stdlib.
-  """
-
-  def __init__(self, *args):
-    TServer.__init__(self, *args)
-    self.children = []
-
-  def serve(self):
-    def try_close(file):
-      try:
-        file.close()
-      except IOError, e:
-        logging.warning(e, exc_info=True)
-
-
-    self.serverTransport.listen()
-    while True:
-      client = self.serverTransport.accept()
-      try:
-        pid = os.fork()
-
-        if pid: # parent
-          # add before collect, otherwise you race w/ waitpid
-          self.children.append(pid)
-          self.collect_children()
-
-          # Parent must close socket or the connection may not get
-          # closed promptly
-          itrans = self.inputTransportFactory.getTransport(client)
-          otrans = self.outputTransportFactory.getTransport(client)
-          try_close(itrans)
-          try_close(otrans)
-        else:
-          itrans = self.inputTransportFactory.getTransport(client)
-          otrans = self.outputTransportFactory.getTransport(client)
-
-          iprot = self.inputProtocolFactory.getProtocol(itrans)
-          oprot = self.outputProtocolFactory.getProtocol(otrans)
-
-          ecode = 0
-          try:
-            try:
-              while True:
-                self.processor.process(iprot, oprot)
-            except TTransport.TTransportException, tx:
-              pass
-            except Exception, e:
-              logging.exception(e)
-              ecode = 1
-          finally:
-            try_close(itrans)
-            try_close(otrans)
-
-          os._exit(ecode)
-
-      except TTransport.TTransportException, tx:
-        pass
-      except Exception, x:
-        logging.exception(x)
-
-
-  def collect_children(self):
-    while self.children:
-      try:
-        pid, status = os.waitpid(0, os.WNOHANG)
-      except os.error:
-        pid = None
-
-      if pid:
-        self.children.remove(pid)
-      else:
-        break
-
-
diff --git a/module/lib/thrift/server/__init__.py b/module/lib/thrift/server/__init__.py
deleted file mode 100644
index 1bf6e254e..000000000
--- a/module/lib/thrift/server/__init__.py
+++ /dev/null
@@ -1,20 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-__all__ = ['TServer', 'TNonblockingServer']
diff --git a/module/lib/thrift/transport/THttpClient.py b/module/lib/thrift/transport/THttpClient.py
deleted file mode 100644
index 50269785c..000000000
--- a/module/lib/thrift/transport/THttpClient.py
+++ /dev/null
@@ -1,126 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-from TTransport import *
-from cStringIO import StringIO
-
-import urlparse
-import httplib
-import warnings
-import socket
-
-class THttpClient(TTransportBase):
-
-  """Http implementation of TTransport base."""
-
-  def __init__(self, uri_or_host, port=None, path=None):
-    """THttpClient supports two different types constructor parameters.
-
-    THttpClient(host, port, path) - deprecated
-    THttpClient(uri)
-
-    Only the second supports https."""
-
-    if port is not None:
-      warnings.warn("Please use the THttpClient('http://host:port/path') syntax", DeprecationWarning, stacklevel=2)
-      self.host = uri_or_host
-      self.port = port
-      assert path
-      self.path = path
-      self.scheme = 'http'
-    else:
-      parsed = urlparse.urlparse(uri_or_host)
-      self.scheme = parsed.scheme
-      assert self.scheme in ('http', 'https')
-      if self.scheme == 'http':
-        self.port = parsed.port or httplib.HTTP_PORT
-      elif self.scheme == 'https':
-        self.port = parsed.port or httplib.HTTPS_PORT
-      self.host = parsed.hostname
-      self.path = parsed.path
-      if parsed.query:
-        self.path += '?%s' % parsed.query
-    self.__wbuf = StringIO()
-    self.__http = None
-    self.__timeout = None
-
-  def open(self):
-    if self.scheme == 'http':
-      self.__http = httplib.HTTP(self.host, self.port)
-    else:
-      self.__http = httplib.HTTPS(self.host, self.port)
-
-  def close(self):
-    self.__http.close()
-    self.__http = None
-
-  def isOpen(self):
-    return self.__http != None
-
-  def setTimeout(self, ms):
-    if not hasattr(socket, 'getdefaulttimeout'):
-      raise NotImplementedError
-
-    if ms is None:
-      self.__timeout = None
-    else:
-      self.__timeout = ms/1000.0
-
-  def read(self, sz):
-    return self.__http.file.read(sz)
-
-  def write(self, buf):
-    self.__wbuf.write(buf)
-
-  def __withTimeout(f):
-    def _f(*args, **kwargs):
-      orig_timeout = socket.getdefaulttimeout()
-      socket.setdefaulttimeout(args[0].__timeout)
-      result = f(*args, **kwargs)
-      socket.setdefaulttimeout(orig_timeout)
-      return result
-    return _f
-
-  def flush(self):
-    if self.isOpen():
-      self.close()
-    self.open();
-
-    # Pull data out of buffer
-    data = self.__wbuf.getvalue()
-    self.__wbuf = StringIO()
-
-    # HTTP request
-    self.__http.putrequest('POST', self.path)
-
-    # Write headers
-    self.__http.putheader('Host', self.host)
-    self.__http.putheader('Content-Type', 'application/x-thrift')
-    self.__http.putheader('Content-Length', str(len(data)))
-    self.__http.endheaders()
-
-    # Write payload
-    self.__http.send(data)
-
-    # Get reply to flush the request
-    self.code, self.message, self.headers = self.__http.getreply()
-
-  # Decorate if we know how to timeout
-  if hasattr(socket, 'getdefaulttimeout'):
-    flush = __withTimeout(flush)
diff --git a/module/lib/thrift/transport/TSocket.py b/module/lib/thrift/transport/TSocket.py
deleted file mode 100644
index 4e0e1874f..000000000
--- a/module/lib/thrift/transport/TSocket.py
+++ /dev/null
@@ -1,163 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-from TTransport import *
-import os
-import errno
-import socket
-import sys
-
-class TSocketBase(TTransportBase):
-  def _resolveAddr(self):
-    if self._unix_socket is not None:
-      return [(socket.AF_UNIX, socket.SOCK_STREAM, None, None, self._unix_socket)]
-    else:
-      return socket.getaddrinfo(self.host, self.port, socket.AF_UNSPEC, socket.SOCK_STREAM, 0, socket.AI_PASSIVE | socket.AI_ADDRCONFIG)
-
-  def close(self):
-    if self.handle:
-      self.handle.close()
-      self.handle = None
-
-class TSocket(TSocketBase):
-  """Socket implementation of TTransport base."""
-
-  def __init__(self, host='localhost', port=9090, unix_socket=None):
-    """Initialize a TSocket
-
-    @param host(str)  The host to connect to.
-    @param port(int)  The (TCP) port to connect to.
-    @param unix_socket(str)  The filename of a unix socket to connect to.
-                             (host and port will be ignored.)
-    """
-
-    self.host = host
-    self.port = port
-    self.handle = None
-    self._unix_socket = unix_socket
-    self._timeout = None
-
-  def setHandle(self, h):
-    self.handle = h
-
-  def isOpen(self):
-    return self.handle is not None
-
-  def setTimeout(self, ms):
-    if ms is None:
-      self._timeout = None
-    else:
-      self._timeout = ms/1000.0
-
-    if self.handle is not None:
-      self.handle.settimeout(self._timeout)
-
-  def open(self):
-    try:
-      res0 = self._resolveAddr()
-      for res in res0:
-        self.handle = socket.socket(res[0], res[1])
-        self.handle.settimeout(self._timeout)
-        try:
-          self.handle.connect(res[4])
-        except socket.error, e:
-          if res is not res0[-1]:
-            continue
-          else:
-            raise e
-        break
-    except socket.error, e:
-      if self._unix_socket:
-        message = 'Could not connect to socket %s' % self._unix_socket
-      else:
-        message = 'Could not connect to %s:%d' % (self.host, self.port)
-      raise TTransportException(type=TTransportException.NOT_OPEN, message=message)
-
-  def read(self, sz):
-    try:
-      buff = self.handle.recv(sz)
-    except socket.error, e:
-      if (e.args[0] == errno.ECONNRESET and
-          (sys.platform == 'darwin' or sys.platform.startswith('freebsd'))):
-        # freebsd and Mach don't follow POSIX semantic of recv
-        # and fail with ECONNRESET if peer performed shutdown.
-        # See corresponding comment and code in TSocket::read()
-        # in lib/cpp/src/transport/TSocket.cpp.
-        self.close()
-        # Trigger the check to raise the END_OF_FILE exception below.
-        buff = ''
-      else:
-        raise
-    if len(buff) == 0:
-      raise TTransportException(type=TTransportException.END_OF_FILE, message='TSocket read 0 bytes')
-    return buff
-
-  def write(self, buff):
-    if not self.handle:
-      raise TTransportException(type=TTransportException.NOT_OPEN, message='Transport not open')
-    sent = 0
-    have = len(buff)
-    while sent < have:
-      plus = self.handle.send(buff)
-      if plus == 0:
-        raise TTransportException(type=TTransportException.END_OF_FILE, message='TSocket sent 0 bytes')
-      sent += plus
-      buff = buff[plus:]
-
-  def flush(self):
-    pass
-
-class TServerSocket(TSocketBase, TServerTransportBase):
-  """Socket implementation of TServerTransport base."""
-
-  def __init__(self, host=None, port=9090, unix_socket=None):
-    self.host = host
-    self.port = port
-    self._unix_socket = unix_socket
-    self.handle = None
-
-  def listen(self):
-    res0 = self._resolveAddr()
-    for res in res0:
-      if res[0] is socket.AF_INET6 or res is res0[-1]:
-        break
-
-    # We need remove the old unix socket if the file exists and
-    # nobody is listening on it.
-    if self._unix_socket:
-      tmp = socket.socket(res[0], res[1])
-      try:
-        tmp.connect(res[4])
-      except socket.error, err:
-        eno, message = err.args
-        if eno == errno.ECONNREFUSED:
-          os.unlink(res[4])
-
-    self.handle = socket.socket(res[0], res[1])
-    self.handle.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-    if hasattr(self.handle, 'settimeout'):
-      self.handle.settimeout(None)
-    self.handle.bind(res[4])
-    self.handle.listen(128)
-
-  def accept(self):
-    client, addr = self.handle.accept()
-    result = TSocket()
-    result.setHandle(client)
-    return result
diff --git a/module/lib/thrift/transport/TTransport.py b/module/lib/thrift/transport/TTransport.py
deleted file mode 100644
index 12e51a9bf..000000000
--- a/module/lib/thrift/transport/TTransport.py
+++ /dev/null
@@ -1,331 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-from cStringIO import StringIO
-from struct import pack,unpack
-from thrift.Thrift import TException
-
-class TTransportException(TException):
-
-  """Custom Transport Exception class"""
-
-  UNKNOWN = 0
-  NOT_OPEN = 1
-  ALREADY_OPEN = 2
-  TIMED_OUT = 3
-  END_OF_FILE = 4
-
-  def __init__(self, type=UNKNOWN, message=None):
-    TException.__init__(self, message)
-    self.type = type
-
-class TTransportBase:
-
-  """Base class for Thrift transport layer."""
-
-  def isOpen(self):
-    pass
-
-  def open(self):
-    pass
-
-  def close(self):
-    pass
-
-  def read(self, sz):
-    pass
-
-  def readAll(self, sz):
-    buff = ''
-    have = 0
-    while (have < sz):
-      chunk = self.read(sz-have)
-      have += len(chunk)
-      buff += chunk
-
-      if len(chunk) == 0:
-        raise EOFError()
-
-    return buff
-
-  def write(self, buf):
-    pass
-
-  def flush(self):
-    pass
-
-# This class should be thought of as an interface.
-class CReadableTransport:
-  """base class for transports that are readable from C"""
-
-  # TODO(dreiss): Think about changing this interface to allow us to use
-  #               a (Python, not c) StringIO instead, because it allows
-  #               you to write after reading.
-
-  # NOTE: This is a classic class, so properties will NOT work
-  #       correctly for setting.
-  @property
-  def cstringio_buf(self):
-    """A cStringIO buffer that contains the current chunk we are reading."""
-    pass
-
-  def cstringio_refill(self, partialread, reqlen):
-    """Refills cstringio_buf.
-
-    Returns the currently used buffer (which can but need not be the same as
-    the old cstringio_buf). partialread is what the C code has read from the
-    buffer, and should be inserted into the buffer before any more reads.  The
-    return value must be a new, not borrowed reference.  Something along the
-    lines of self._buf should be fine.
-
-    If reqlen bytes can't be read, throw EOFError.
-    """
-    pass
-
-class TServerTransportBase:
-
-  """Base class for Thrift server transports."""
-
-  def listen(self):
-    pass
-
-  def accept(self):
-    pass
-
-  def close(self):
-    pass
-
-class TTransportFactoryBase:
-
-  """Base class for a Transport Factory"""
-
-  def getTransport(self, trans):
-    return trans
-
-class TBufferedTransportFactory:
-
-  """Factory transport that builds buffered transports"""
-
-  def getTransport(self, trans):
-    buffered = TBufferedTransport(trans)
-    return buffered
-
-
-class TBufferedTransport(TTransportBase,CReadableTransport):
-
-  """Class that wraps another transport and buffers its I/O.
-
-  The implementation uses a (configurable) fixed-size read buffer
-  but buffers all writes until a flush is performed.
-  """
-
-  DEFAULT_BUFFER = 4096
-
-  def __init__(self, trans, rbuf_size = DEFAULT_BUFFER):
-    self.__trans = trans
-    self.__wbuf = StringIO()
-    self.__rbuf = StringIO("")
-    self.__rbuf_size = rbuf_size
-
-  def isOpen(self):
-    return self.__trans.isOpen()
-
-  def open(self):
-    return self.__trans.open()
-
-  def close(self):
-    return self.__trans.close()
-
-  def read(self, sz):
-    ret = self.__rbuf.read(sz)
-    if len(ret) != 0:
-      return ret
-
-    self.__rbuf = StringIO(self.__trans.read(max(sz, self.__rbuf_size)))
-    return self.__rbuf.read(sz)
-
-  def write(self, buf):
-    self.__wbuf.write(buf)
-
-  def flush(self):
-    out = self.__wbuf.getvalue()
-    # reset wbuf before write/flush to preserve state on underlying failure
-    self.__wbuf = StringIO()
-    self.__trans.write(out)
-    self.__trans.flush()
-
-  # Implement the CReadableTransport interface.
-  @property
-  def cstringio_buf(self):
-    return self.__rbuf
-
-  def cstringio_refill(self, partialread, reqlen):
-    retstring = partialread
-    if reqlen < self.__rbuf_size:
-      # try to make a read of as much as we can.
-      retstring += self.__trans.read(self.__rbuf_size)
-
-    # but make sure we do read reqlen bytes.
-    if len(retstring) < reqlen:
-      retstring += self.__trans.readAll(reqlen - len(retstring))
-
-    self.__rbuf = StringIO(retstring)
-    return self.__rbuf
-
-class TMemoryBuffer(TTransportBase, CReadableTransport):
-  """Wraps a cStringIO object as a TTransport.
-
-  NOTE: Unlike the C++ version of this class, you cannot write to it
-        then immediately read from it.  If you want to read from a
-        TMemoryBuffer, you must either pass a string to the constructor.
-  TODO(dreiss): Make this work like the C++ version.
-  """
-
-  def __init__(self, value=None):
-    """value -- a value to read from for stringio
-
-    If value is set, this will be a transport for reading,
-    otherwise, it is for writing"""
-    if value is not None:
-      self._buffer = StringIO(value)
-    else:
-      self._buffer = StringIO()
-
-  def isOpen(self):
-    return not self._buffer.closed
-
-  def open(self):
-    pass
-
-  def close(self):
-    self._buffer.close()
-
-  def read(self, sz):
-    return self._buffer.read(sz)
-
-  def write(self, buf):
-    self._buffer.write(buf)
-
-  def flush(self):
-    pass
-
-  def getvalue(self):
-    return self._buffer.getvalue()
-
-  # Implement the CReadableTransport interface.
-  @property
-  def cstringio_buf(self):
-    return self._buffer
-
-  def cstringio_refill(self, partialread, reqlen):
-    # only one shot at reading...
-    raise EOFError()
-
-class TFramedTransportFactory:
-
-  """Factory transport that builds framed transports"""
-
-  def getTransport(self, trans):
-    framed = TFramedTransport(trans)
-    return framed
-
-
-class TFramedTransport(TTransportBase, CReadableTransport):
-
-  """Class that wraps another transport and frames its I/O when writing."""
-
-  def __init__(self, trans,):
-    self.__trans = trans
-    self.__rbuf = StringIO()
-    self.__wbuf = StringIO()
-
-  def isOpen(self):
-    return self.__trans.isOpen()
-
-  def open(self):
-    return self.__trans.open()
-
-  def close(self):
-    return self.__trans.close()
-
-  def read(self, sz):
-    ret = self.__rbuf.read(sz)
-    if len(ret) != 0:
-      return ret
-
-    self.readFrame()
-    return self.__rbuf.read(sz)
-
-  def readFrame(self):
-    buff = self.__trans.readAll(4)
-    sz, = unpack('!i', buff)
-    self.__rbuf = StringIO(self.__trans.readAll(sz))
-
-  def write(self, buf):
-    self.__wbuf.write(buf)
-
-  def flush(self):
-    wout = self.__wbuf.getvalue()
-    wsz = len(wout)
-    # reset wbuf before write/flush to preserve state on underlying failure
-    self.__wbuf = StringIO()
-    # N.B.: Doing this string concatenation is WAY cheaper than making
-    # two separate calls to the underlying socket object. Socket writes in
-    # Python turn out to be REALLY expensive, but it seems to do a pretty
-    # good job of managing string buffer operations without excessive copies
-    buf = pack("!i", wsz) + wout
-    self.__trans.write(buf)
-    self.__trans.flush()
-
-  # Implement the CReadableTransport interface.
-  @property
-  def cstringio_buf(self):
-    return self.__rbuf
-
-  def cstringio_refill(self, prefix, reqlen):
-    # self.__rbuf will already be empty here because fastbinary doesn't
-    # ask for a refill until the previous buffer is empty.  Therefore,
-    # we can start reading new frames immediately.
-    while len(prefix) < reqlen:
-      self.readFrame()
-      prefix += self.__rbuf.getvalue()
-    self.__rbuf = StringIO(prefix)
-    return self.__rbuf
-
-
-class TFileObjectTransport(TTransportBase):
-  """Wraps a file-like object to make it work as a Thrift transport."""
-
-  def __init__(self, fileobj):
-    self.fileobj = fileobj
-
-  def isOpen(self):
-    return True
-
-  def close(self):
-    self.fileobj.close()
-
-  def read(self, sz):
-    return self.fileobj.read(sz)
-
-  def write(self, buf):
-    self.fileobj.write(buf)
-
-  def flush(self):
-    self.fileobj.flush()
diff --git a/module/lib/thrift/transport/TTwisted.py b/module/lib/thrift/transport/TTwisted.py
deleted file mode 100644
index b6dcb4e0b..000000000
--- a/module/lib/thrift/transport/TTwisted.py
+++ /dev/null
@@ -1,219 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-from zope.interface import implements, Interface, Attribute
-from twisted.internet.protocol import Protocol, ServerFactory, ClientFactory, \
-    connectionDone
-from twisted.internet import defer
-from twisted.protocols import basic
-from twisted.python import log
-from twisted.web import server, resource, http
-
-from thrift.transport import TTransport
-from cStringIO import StringIO
-
-
-class TMessageSenderTransport(TTransport.TTransportBase):
-
-    def __init__(self):
-        self.__wbuf = StringIO()
-
-    def write(self, buf):
-        self.__wbuf.write(buf)
-
-    def flush(self):
-        msg = self.__wbuf.getvalue()
-        self.__wbuf = StringIO()
-        self.sendMessage(msg)
-
-    def sendMessage(self, message):
-        raise NotImplementedError
-
-
-class TCallbackTransport(TMessageSenderTransport):
-
-    def __init__(self, func):
-        TMessageSenderTransport.__init__(self)
-        self.func = func
-
-    def sendMessage(self, message):
-        self.func(message)
-
-
-class ThriftClientProtocol(basic.Int32StringReceiver):
-
-    MAX_LENGTH = 2 ** 31 - 1
-
-    def __init__(self, client_class, iprot_factory, oprot_factory=None):
-        self._client_class = client_class
-        self._iprot_factory = iprot_factory
-        if oprot_factory is None:
-            self._oprot_factory = iprot_factory
-        else:
-            self._oprot_factory = oprot_factory
-
-        self.recv_map = {}
-        self.started = defer.Deferred()
-
-    def dispatch(self, msg):
-        self.sendString(msg)
-
-    def connectionMade(self):
-        tmo = TCallbackTransport(self.dispatch)
-        self.client = self._client_class(tmo, self._oprot_factory)
-        self.started.callback(self.client)
-
-    def connectionLost(self, reason=connectionDone):
-        for k,v in self.client._reqs.iteritems():
-            tex = TTransport.TTransportException(
-                type=TTransport.TTransportException.END_OF_FILE,
-                message='Connection closed')
-            v.errback(tex)
-
-    def stringReceived(self, frame):
-        tr = TTransport.TMemoryBuffer(frame)
-        iprot = self._iprot_factory.getProtocol(tr)
-        (fname, mtype, rseqid) = iprot.readMessageBegin()
-
-        try:
-            method = self.recv_map[fname]
-        except KeyError:
-            method = getattr(self.client, 'recv_' + fname)
-            self.recv_map[fname] = method
-
-        method(iprot, mtype, rseqid)
-
-
-class ThriftServerProtocol(basic.Int32StringReceiver):
-
-    MAX_LENGTH = 2 ** 31 - 1
-
-    def dispatch(self, msg):
-        self.sendString(msg)
-
-    def processError(self, error):
-        self.transport.loseConnection()
-
-    def processOk(self, _, tmo):
-        msg = tmo.getvalue()
-
-        if len(msg) > 0:
-            self.dispatch(msg)
-
-    def stringReceived(self, frame):
-        tmi = TTransport.TMemoryBuffer(frame)
-        tmo = TTransport.TMemoryBuffer()
-
-        iprot = self.factory.iprot_factory.getProtocol(tmi)
-        oprot = self.factory.oprot_factory.getProtocol(tmo)
-
-        d = self.factory.processor.process(iprot, oprot)
-        d.addCallbacks(self.processOk, self.processError,
-            callbackArgs=(tmo,))
-
-
-class IThriftServerFactory(Interface):
-
-    processor = Attribute("Thrift processor")
-
-    iprot_factory = Attribute("Input protocol factory")
-
-    oprot_factory = Attribute("Output protocol factory")
-
-
-class IThriftClientFactory(Interface):
-
-    client_class = Attribute("Thrift client class")
-
-    iprot_factory = Attribute("Input protocol factory")
-
-    oprot_factory = Attribute("Output protocol factory")
-
-
-class ThriftServerFactory(ServerFactory):
-
-    implements(IThriftServerFactory)
-
-    protocol = ThriftServerProtocol
-
-    def __init__(self, processor, iprot_factory, oprot_factory=None):
-        self.processor = processor
-        self.iprot_factory = iprot_factory
-        if oprot_factory is None:
-            self.oprot_factory = iprot_factory
-        else:
-            self.oprot_factory = oprot_factory
-
-
-class ThriftClientFactory(ClientFactory):
-
-    implements(IThriftClientFactory)
-
-    protocol = ThriftClientProtocol
-
-    def __init__(self, client_class, iprot_factory, oprot_factory=None):
-        self.client_class = client_class
-        self.iprot_factory = iprot_factory
-        if oprot_factory is None:
-            self.oprot_factory = iprot_factory
-        else:
-            self.oprot_factory = oprot_factory
-
-    def buildProtocol(self, addr):
-        p = self.protocol(self.client_class, self.iprot_factory,
-            self.oprot_factory)
-        p.factory = self
-        return p
-
-
-class ThriftResource(resource.Resource):
-
-    allowedMethods = ('POST',)
-
-    def __init__(self, processor, inputProtocolFactory,
-        outputProtocolFactory=None):
-        resource.Resource.__init__(self)
-        self.inputProtocolFactory = inputProtocolFactory
-        if outputProtocolFactory is None:
-            self.outputProtocolFactory = inputProtocolFactory
-        else:
-            self.outputProtocolFactory = outputProtocolFactory
-        self.processor = processor
-
-    def getChild(self, path, request):
-        return self
-
-    def _cbProcess(self, _, request, tmo):
-        msg = tmo.getvalue()
-        request.setResponseCode(http.OK)
-        request.setHeader("content-type", "application/x-thrift")
-        request.write(msg)
-        request.finish()
-
-    def render_POST(self, request):
-        request.content.seek(0, 0)
-        data = request.content.read()
-        tmi = TTransport.TMemoryBuffer(data)
-        tmo = TTransport.TMemoryBuffer()
-
-        iprot = self.inputProtocolFactory.getProtocol(tmi)
-        oprot = self.outputProtocolFactory.getProtocol(tmo)
-
-        d = self.processor.process(iprot, oprot)
-        d.addCallback(self._cbProcess, request, tmo)
-        return server.NOT_DONE_YET
diff --git a/module/lib/thrift/transport/TZlibTransport.py b/module/lib/thrift/transport/TZlibTransport.py
deleted file mode 100644
index 784d4e1e0..000000000
--- a/module/lib/thrift/transport/TZlibTransport.py
+++ /dev/null
@@ -1,261 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-'''
-TZlibTransport provides a compressed transport and transport factory
-class, using the python standard library zlib module to implement
-data compression.
-'''
-
-from __future__ import division
-import zlib
-from cStringIO import StringIO
-from TTransport import TTransportBase, CReadableTransport
-
-class TZlibTransportFactory(object):
-  '''
-  Factory transport that builds zlib compressed transports.
-  
-  This factory caches the last single client/transport that it was passed
-  and returns the same TZlibTransport object that was created.
-  
-  This caching means the TServer class will get the _same_ transport
-  object for both input and output transports from this factory.
-  (For non-threaded scenarios only, since the cache only holds one object)
-  
-  The purpose of this caching is to allocate only one TZlibTransport where
-  only one is really needed (since it must have separate read/write buffers),
-  and makes the statistics from getCompSavings() and getCompRatio()
-  easier to understand.
-  '''
-
-  # class scoped cache of last transport given and zlibtransport returned
-  _last_trans = None
-  _last_z = None
-
-  def getTransport(self, trans, compresslevel=9):
-    '''Wrap a transport , trans, with the TZlibTransport
-    compressed transport class, returning a new
-    transport to the caller.
-    
-    @param compresslevel: The zlib compression level, ranging
-    from 0 (no compression) to 9 (best compression).  Defaults to 9.
-    @type compresslevel: int
-    
-    This method returns a TZlibTransport which wraps the
-    passed C{trans} TTransport derived instance.
-    '''
-    if trans == self._last_trans:
-      return self._last_z
-    ztrans = TZlibTransport(trans, compresslevel)
-    self._last_trans = trans
-    self._last_z = ztrans
-    return ztrans
-
-
-class TZlibTransport(TTransportBase, CReadableTransport):
-  '''
-  Class that wraps a transport with zlib, compressing writes
-  and decompresses reads, using the python standard
-  library zlib module.
-  '''
-
-  # Read buffer size for the python fastbinary C extension,
-  # the TBinaryProtocolAccelerated class.
-  DEFAULT_BUFFSIZE = 4096
-
-  def __init__(self, trans, compresslevel=9):
-    '''
-    Create a new TZlibTransport, wrapping C{trans}, another
-    TTransport derived object.
-    
-    @param trans: A thrift transport object, i.e. a TSocket() object.
-    @type trans: TTransport
-    @param compresslevel: The zlib compression level, ranging
-    from 0 (no compression) to 9 (best compression).  Default is 9.
-    @type compresslevel: int
-    '''
-    self.__trans = trans
-    self.compresslevel = compresslevel
-    self.__rbuf = StringIO()
-    self.__wbuf = StringIO()
-    self._init_zlib()
-    self._init_stats()
-
-  def _reinit_buffers(self):
-    '''
-    Internal method to initialize/reset the internal StringIO objects
-    for read and write buffers.
-    '''
-    self.__rbuf = StringIO()
-    self.__wbuf = StringIO()
-
-  def _init_stats(self):
-    '''
-    Internal method to reset the internal statistics counters
-    for compression ratios and bandwidth savings.
-    '''
-    self.bytes_in = 0
-    self.bytes_out = 0
-    self.bytes_in_comp = 0
-    self.bytes_out_comp = 0
-
-  def _init_zlib(self):
-    '''
-    Internal method for setting up the zlib compression and
-    decompression objects.
-    '''
-    self._zcomp_read = zlib.decompressobj()
-    self._zcomp_write = zlib.compressobj(self.compresslevel)
-
-  def getCompRatio(self):
-    '''
-    Get the current measured compression ratios (in,out) from
-    this transport.
-    
-    Returns a tuple of: 
-    (inbound_compression_ratio, outbound_compression_ratio)
-    
-    The compression ratios are computed as:
-        compressed / uncompressed
-
-    E.g., data that compresses by 10x will have a ratio of: 0.10
-    and data that compresses to half of ts original size will
-    have a ratio of 0.5
-    
-    None is returned if no bytes have yet been processed in
-    a particular direction.
-    '''
-    r_percent, w_percent = (None, None)
-    if self.bytes_in > 0:
-      r_percent = self.bytes_in_comp / self.bytes_in
-    if self.bytes_out > 0:
-      w_percent = self.bytes_out_comp / self.bytes_out
-    return (r_percent, w_percent)
-
-  def getCompSavings(self):
-    '''
-    Get the current count of saved bytes due to data
-    compression.
-    
-    Returns a tuple of:
-    (inbound_saved_bytes, outbound_saved_bytes)
-    
-    Note: if compression is actually expanding your
-    data (only likely with very tiny thrift objects), then
-    the values returned will be negative.
-    '''
-    r_saved = self.bytes_in - self.bytes_in_comp
-    w_saved = self.bytes_out - self.bytes_out_comp
-    return (r_saved, w_saved)
-
-  def isOpen(self):
-    '''Return the underlying transport's open status'''
-    return self.__trans.isOpen()
-
-  def open(self):
-    """Open the underlying transport"""
-    self._init_stats()
-    return self.__trans.open()
-
-  def listen(self):
-    '''Invoke the underlying transport's listen() method'''
-    self.__trans.listen()
-
-  def accept(self):
-    '''Accept connections on the underlying transport'''
-    return self.__trans.accept()
-
-  def close(self):
-    '''Close the underlying transport,'''
-    self._reinit_buffers()
-    self._init_zlib()
-    return self.__trans.close()
-
-  def read(self, sz):
-    '''
-    Read up to sz bytes from the decompressed bytes buffer, and
-    read from the underlying transport if the decompression
-    buffer is empty.
-    '''
-    ret = self.__rbuf.read(sz)
-    if len(ret) > 0:
-      return ret
-    # keep reading from transport until something comes back
-    while True:
-      if self.readComp(sz):
-        break
-    ret = self.__rbuf.read(sz)
-    return ret
-
-  def readComp(self, sz):
-    '''
-    Read compressed data from the underlying transport, then
-    decompress it and append it to the internal StringIO read buffer
-    '''
-    zbuf = self.__trans.read(sz)
-    zbuf = self._zcomp_read.unconsumed_tail + zbuf
-    buf = self._zcomp_read.decompress(zbuf)
-    self.bytes_in += len(zbuf)
-    self.bytes_in_comp += len(buf)
-    old = self.__rbuf.read()
-    self.__rbuf = StringIO(old + buf)
-    if len(old) + len(buf) == 0:
-      return False
-    return True
-
-  def write(self, buf):
-    '''
-    Write some bytes, putting them into the internal write
-    buffer for eventual compression.
-    '''
-    self.__wbuf.write(buf)
-
-  def flush(self):
-    '''
-    Flush any queued up data in the write buffer and ensure the
-    compression buffer is flushed out to the underlying transport
-    '''
-    wout = self.__wbuf.getvalue()
-    if len(wout) > 0:
-      zbuf = self._zcomp_write.compress(wout)
-      self.bytes_out += len(wout)
-      self.bytes_out_comp += len(zbuf)
-    else:
-      zbuf = ''
-    ztail = self._zcomp_write.flush(zlib.Z_SYNC_FLUSH)
-    self.bytes_out_comp += len(ztail)
-    if (len(zbuf) + len(ztail)) > 0:
-      self.__wbuf = StringIO()
-      self.__trans.write(zbuf + ztail)
-    self.__trans.flush()
-
-  @property
-  def cstringio_buf(self):
-    '''Implement the CReadableTransport interface'''
-    return self.__rbuf
-
-  def cstringio_refill(self, partialread, reqlen):
-    '''Implement the CReadableTransport interface for refill'''
-    retstring = partialread
-    if reqlen < self.DEFAULT_BUFFSIZE:
-      retstring += self.read(self.DEFAULT_BUFFSIZE)
-    while len(retstring) < reqlen:
-      retstring += self.read(reqlen - len(retstring))
-    self.__rbuf = StringIO(retstring)
-    return self.__rbuf
diff --git a/module/lib/thrift/transport/__init__.py b/module/lib/thrift/transport/__init__.py
deleted file mode 100644
index 46e54fe6b..000000000
--- a/module/lib/thrift/transport/__init__.py
+++ /dev/null
@@ -1,20 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-__all__ = ['TTransport', 'TSocket', 'THttpClient','TZlibTransport']
diff --git a/module/network/Browser.py b/module/network/Browser.py
index d68a23687..25cbf669b 100644
--- a/module/network/Browser.py
+++ b/module/network/Browser.py
@@ -16,7 +16,7 @@ class Browser(object):
         self.options = options #holds pycurl options
         self.bucket = bucket
 
-        self.cj = None # needs to be setted later
+        self.cj = None # needs to be set later
         self._size = 0
 
         self.renewHTTPRequest()
@@ -55,6 +55,13 @@ class Browser(object):
         return 0
 
     @property
+    def name(self):
+        if self.dl:
+            return self.dl.name
+        else:
+            return ""
+
+    @property
     def arrived(self):
         if self.dl:
             return self.dl.arrived
@@ -80,11 +87,11 @@ class Browser(object):
             self.dl.abort = True
 
     def httpDownload(self, url, filename, get={}, post={}, ref=True, cookies=True, chunks=1, resume=False,
-                     progressNotify=None, disposition=False):
+                    disposition=False):
         """ this can also download ftp """
         self._size = 0
         self.dl = HTTPDownload(url, filename, get, post, self.lastEffectiveURL if ref else None,
-            self.cj if cookies else None, self.bucket, self.options, progressNotify, disposition)
+            self.cj if cookies else None, self.bucket, self.options, disposition)
         name = self.dl.download(chunks, resume)
         self._size = self.dl.size
 
diff --git a/module/network/Bucket.py b/module/network/Bucket.py
index 69da277ae..db67faa4a 100644
--- a/module/network/Bucket.py
+++ b/module/network/Bucket.py
@@ -20,15 +20,18 @@
 from time import time
 from threading import Lock
 
+# 10kb minimum rate
+MIN_RATE = 10240
+
 class Bucket:
     def __init__(self):
-        self.rate = 0
+        self.rate = 0 # bytes per second, maximum targeted throughput
         self.tokens = 0
         self.timestamp = time()
         self.lock = Lock()
 
     def __nonzero__(self):
-        return False if self.rate < 10240 else True
+        return False if self.rate < MIN_RATE else True
 
     def setRate(self, rate):
         self.lock.acquire()
@@ -36,8 +39,8 @@ class Bucket:
         self.lock.release()
 
     def consumed(self, amount):
-        """ return time the process have to sleep, after consumed specified amount """
-        if self.rate < 10240: return 0 #min. 10kb, may become unresponsive otherwise
+        """ return the time the process has to sleep, after it consumed a specified amount """
+        if self.rate < MIN_RATE: return 0 #May become unresponsive otherwise
         self.lock.acquire()
 
         self.calc_tokens()
@@ -47,7 +50,6 @@ class Bucket:
             time = -self.tokens/float(self.rate)
         else:
             time = 0
-        
 
         self.lock.release()
         return time
diff --git a/module/network/CookieJar.py b/module/network/CookieJar.py
index c05812334..ea2c43a9e 100644
--- a/module/network/CookieJar.py
+++ b/module/network/CookieJar.py
@@ -19,11 +19,14 @@
 
 from time import time
 
+# TODO: replace with simplecookie?
 class CookieJar():
-    def __init__(self, pluginname, account=None):
+    def __init__(self, pluginname):
         self.cookies = {}
-        self.plugin = pluginname
-        self.account = account
+        self.pluginname = pluginname
+
+    def __repr__(self):
+        return ("<CookieJar plugin=%s>\n\t" % self.pluginname) + "\n\t".join(self.cookies.values())
 
     def addCookies(self, clist):
         for c in clist:
@@ -33,18 +36,18 @@ class CookieJar():
     def getCookies(self):
         return self.cookies.values()
 
-    def parseCookie(self, name):
+    def getCookie(self, name):
         if name in self.cookies:
             return self.cookies[name].split("\t")[6]
         else:
             return None
 
-    def getCookie(self, name):
-        return self.parseCookie(name)
+    def setCookie(self, domain, name, value, path="/", exp=None):
+        if not exp: exp = time() + 3600 * 24 * 180
 
-    def setCookie(self, domain, name, value, path="/", exp=time()+3600*24*180):
-        s = ".%s	TRUE	%s	FALSE	%s	%s	%s" % (domain, path, exp, name, value)
+        # dot makes it valid on all subdomains
+        s = ".%s	TRUE	%s	FALSE	%s	%s	%s" % (domain.strip("."), path, exp, name, value)
         self.cookies[name] = s
 
     def clear(self):
-        self.cookies = {}
+        self.cookies = {}
\ No newline at end of file
diff --git a/module/network/HTTPChunk.py b/module/network/HTTPChunk.py
index b637aef32..84a2acc5f 100644
--- a/module/network/HTTPChunk.py
+++ b/module/network/HTTPChunk.py
@@ -20,10 +20,13 @@ from os import remove, stat, fsync
 from os.path import exists
 from time import sleep
 from re import search
-from module.utils import fs_encode
+
 import codecs
 import pycurl
 
+from module.utils import remove_chars
+from module.utils.fs import fs_encode
+
 from HTTPRequest import HTTPRequest
 
 class WrongFormat(Exception):
@@ -204,7 +207,7 @@ class HTTPChunk(HTTPRequest):
 
     def writeHeader(self, buf):
         self.header += buf
-        #@TODO forward headers?, this is possibly unneeeded, when we just parse valid 200 headers
+        #@TODO forward headers?, this is possibly unneeded, when we just parse valid 200 headers
         # as first chunk, we will parse the headers
         if not self.range and self.header.endswith("\r\n\r\n"):
             self.parseHeader()
@@ -233,8 +236,8 @@ class HTTPChunk(HTTPRequest):
             sleep(self.p.bucket.consumed(size))
         else:
             # Avoid small buffers, increasing sleep time slowly if buffer size gets smaller
-            # otherwise reduce sleep time percentual (values are based on tests)
-            # So in general cpu time is saved without reducing bandwith too much
+            # otherwise reduce sleep time percentile (values are based on tests)
+            # So in general cpu time is saved without reducing bandwidth too much
 
             if size < self.lastSize:
                 self.sleep += 0.002
@@ -250,17 +253,19 @@ class HTTPChunk(HTTPRequest):
 
 
     def parseHeader(self):
-        """parse data from recieved header"""
+        """parse data from received header"""
         for orgline in self.decodeResponse(self.header).splitlines():
             line = orgline.strip().lower()
             if line.startswith("accept-ranges") and "bytes" in line:
                 self.p.chunkSupport = True
 
-            if line.startswith("content-disposition") and "filename=" in line:
-                name = orgline.partition("filename=")[2]
-                name = name.replace('"', "").replace("'", "").replace(";", "").strip()
-                self.p.nameDisposition = name
-                self.log.debug("Content-Disposition: %s" % name)
+            if "content-disposition" in line:
+
+                m = search("filename(?P<type>=|\*=(?P<enc>.+)'')(?P<name>.*)", line)
+                if m:
+                    name = remove_chars(m.groupdict()['name'], "\"';/").strip()
+                    self.p._name = name
+                    self.log.debug("Content-Disposition: %s" % name)
 
             if not self.resume and line.startswith("content-length"):
                 self.p.size = int(line.split(":")[1])
@@ -290,4 +295,4 @@ class HTTPChunk(HTTPRequest):
         """ closes everything, unusable after this """
         if self.fp: self.fp.close()
         self.c.close()
-        if hasattr(self, "p"): del self.p
\ No newline at end of file
+        if hasattr(self, "p"): del self.p
diff --git a/module/network/HTTPDownload.py b/module/network/HTTPDownload.py
index fe8075539..498cd5979 100644
--- a/module/network/HTTPDownload.py
+++ b/module/network/HTTPDownload.py
@@ -17,9 +17,9 @@
     @author: RaNaN
 """
 
-from os import remove, fsync
+from os import remove
 from os.path import dirname
-from time import sleep, time
+from time import time
 from shutil import move
 from logging import getLogger
 
@@ -28,14 +28,16 @@ import pycurl
 from HTTPChunk import ChunkInfo, HTTPChunk
 from HTTPRequest import BadHeader
 
-from module.plugins.Plugin import Abort
-from module.utils import save_join, fs_encode
+from module.plugins.Base import Abort
+from module.utils.fs import save_join, fs_encode
+
+# TODO: save content-disposition for resuming
 
 class HTTPDownload():
-    """ loads a url http + ftp """
+    """ loads an url, http + ftp supported """
 
     def __init__(self, url, filename, get={}, post={}, referer=None, cj=None, bucket=None,
-                 options={}, progressNotify=None, disposition=False):
+                 options={}, disposition=False):
         self.url = url
         self.filename = filename  #complete file destination, not only name
         self.get = get
@@ -49,7 +51,7 @@ class HTTPDownload():
 
         self.abort = False
         self.size = 0
-        self.nameDisposition = None #will be parsed from content disposition
+        self._name = ""# will be parsed from content disposition
 
         self.chunks = []
 
@@ -71,8 +73,6 @@ class HTTPDownload():
         self.speeds = []
         self.lastSpeeds = [0, 0]
 
-        self.progressNotify = progressNotify
-
     @property
     def speed(self):
         last = [sum(x) for x in self.lastSpeeds if x]
@@ -87,6 +87,10 @@ class HTTPDownload():
         if not self.size: return 0
         return (self.arrived * 100) / self.size
 
+    @property
+    def name(self):
+        return self._name if self.disposition else ""
+
     def _copyChunks(self):
         init = fs_encode(self.info.getChunkName(0)) #initial chunk name
 
@@ -113,8 +117,8 @@ class HTTPDownload():
                 remove(fname) #remove chunk
             fo.close()
 
-        if self.nameDisposition and self.disposition:
-            self.filename = save_join(dirname(self.filename), self.nameDisposition)
+        if self.name:
+            self.filename = save_join(dirname(self.filename), self.name)
 
         move(init, fs_encode(self.filename))
         self.info.remove() #remove info file
@@ -144,8 +148,7 @@ class HTTPDownload():
         finally:
             self.close()
 
-        if self.nameDisposition and self.disposition: return self.nameDisposition
-        return None
+        return self.name
 
     def _download(self, chunks, resume):
         if not resume:
@@ -169,7 +172,7 @@ class HTTPDownload():
 
         while 1:
             #need to create chunks
-            if not chunksCreated and self.chunkSupport and self.size: #will be setted later by first chunk
+            if not chunksCreated and self.chunkSupport and self.size: #will be set later by first chunk
 
                 if not resume:
                     self.info.setSize(self.size)
@@ -188,7 +191,7 @@ class HTTPDownload():
                         self.chunks.append(c)
                         self.m.add_handle(handle)
                     else:
-                        #close immediatly
+                        #close immediately
                         self.log.debug("Invalid curl handle -> closed")
                         c.close()
 
@@ -202,6 +205,7 @@ class HTTPDownload():
             t = time()
 
             # reduce these calls
+            # when num_q is 0, the loop is exited
             while lastFinishCheck + 0.5 < t:
                 # list of failed curl handles
                 failed = []
@@ -237,10 +241,10 @@ class HTTPDownload():
                         ex = e
                     else:
                         chunksDone.add(curl)
-                if not num_q: # no more infos to get
+                if not num_q: # no more info to get
 
                     # check if init is not finished so we reset download connections
-                    # note that other chunks are closed and downloaded with init too
+                    # note that other chunks are closed and everything downloaded with initial connection
                     if failed and init not in failed and init.c not in chunksDone:
                         self.log.error(_("Download chunks failed, fallback to single connection | %s" % (str(ex))))
 
@@ -281,12 +285,10 @@ class HTTPDownload():
                 self.speeds = [float(a) / (t - lastTimeCheck) for a in diff]
                 self.lastArrived = [c.arrived for c in self.chunks]
                 lastTimeCheck = t
-                self.updateProgress()
 
             if self.abort:
                 raise Abort()
 
-            #sleep(0.003) #supress busy waiting - limits dl speed to  (1 / x) * buffersize
             self.m.select(1)
 
         for chunk in self.chunks:
@@ -294,10 +296,6 @@ class HTTPDownload():
 
         self._copyChunks()
 
-    def updateProgress(self):
-        if self.progressNotify:
-            self.progressNotify(self.percent)
-
     def findChunk(self, handle):
         """ linear search to find a chunk (should be ok since chunk size is usually low) """
         for chunk in self.chunks:
diff --git a/module/network/HTTPRequest.py b/module/network/HTTPRequest.py
index 4747d937f..874da368b 100644
--- a/module/network/HTTPRequest.py
+++ b/module/network/HTTPRequest.py
@@ -25,21 +25,21 @@ from httplib import responses
 from logging import getLogger
 from cStringIO import StringIO
 
-from module.plugins.Plugin import Abort
+from module.plugins.Base import Abort
 
 def myquote(url):
-    return quote(url.encode('utf_8') if isinstance(url, unicode) else url, safe="%/:=&?~#+!$,;'@()*[]")
+    return quote(url.encode('utf8') if isinstance(url, unicode) else url, safe="%/:=&?~#+!$,;'@()*[]")
     
 def myurlencode(data):
     data = dict(data)
-    return urlencode(dict((x.encode('utf_8') if isinstance(x, unicode) else x, \
-        y.encode('utf_8') if isinstance(y, unicode) else y ) for x, y in data.iteritems()))
+    return urlencode(dict((x.encode('utf8') if isinstance(x, unicode) else x, \
+        y.encode('utf8') if isinstance(y, unicode) else y ) for x, y in data.iteritems()))
 
 bad_headers = range(400, 404) + range(405, 418) + range(500, 506)
 
 class BadHeader(Exception):
     def __init__(self, code, content=""):
-        Exception.__init__(self, "Bad server response: %s %s" % (code, responses[int(code)]))
+        Exception.__init__(self, "Bad server response: %s %s" % (code, responses.get(int(code), "Unknown Header")))
         self.code = code
         self.content = content
 
@@ -62,6 +62,7 @@ class HTTPRequest():
 
         self.initHandle()
         self.setInterface(options)
+        self.setOptions(options)
 
         self.c.setopt(pycurl.WRITEFUNCTION, self.write)
         self.c.setopt(pycurl.HEADERFUNCTION, self.writeHeader)
@@ -79,7 +80,8 @@ class HTTPRequest():
         if hasattr(pycurl, "AUTOREFERER"):
             self.c.setopt(pycurl.AUTOREFERER, 1)
         self.c.setopt(pycurl.SSL_VERIFYPEER, 0)
-        self.c.setopt(pycurl.LOW_SPEED_TIME, 30)
+        # Interval for low speed, detects connection loss, but can abort dl if hoster stalls the download
+        self.c.setopt(pycurl.LOW_SPEED_TIME, 45)
         self.c.setopt(pycurl.LOW_SPEED_LIMIT, 5)
 
         #self.c.setopt(pycurl.VERBOSE, 1)
@@ -127,6 +129,11 @@ class HTTPRequest():
         if "timeout" in options:
             self.c.setopt(pycurl.LOW_SPEED_TIME, options["timeout"])
 
+    def setOptions(self, options):
+        """  Sets same options as available in pycurl  """
+        for k, v in options.iteritems():
+            if hasattr(pycurl, k):
+                self.c.setopt(getattr(pycurl, k), v)
 
     def addCookies(self):
         """ put cookies from curl handle to cj """
@@ -153,7 +160,7 @@ class HTTPRequest():
             url = "%s?%s" % (url, get)
 
         self.c.setopt(pycurl.URL, url)
-        self.c.lastUrl = url
+        self.lastURL = url
 
         if post:
             self.c.setopt(pycurl.POST, 1)
@@ -186,18 +193,28 @@ class HTTPRequest():
 
         self.setRequestContext(url, get, post, referer, cookies, multipart)
 
+        # TODO: use http/rfc message instead
         self.header = ""
 
         self.c.setopt(pycurl.HTTPHEADER, self.headers)
 
         if just_header:
             self.c.setopt(pycurl.FOLLOWLOCATION, 0)
-            self.c.setopt(pycurl.NOBODY, 1)
-            self.c.perform()
-            rep = self.header
+            self.c.setopt(pycurl.NOBODY, 1) #TODO: nobody= no post?
+
+            # overwrite HEAD request, we want a common request type
+            if post:
+                self.c.setopt(pycurl.CUSTOMREQUEST, "POST")
+            else:
+                self.c.setopt(pycurl.CUSTOMREQUEST, "GET")
 
-            self.c.setopt(pycurl.FOLLOWLOCATION, 1)
-            self.c.setopt(pycurl.NOBODY, 0)
+            try:
+                self.c.perform()
+                rep = self.header
+            finally:
+                self.c.setopt(pycurl.FOLLOWLOCATION, 1)
+                self.c.setopt(pycurl.NOBODY, 0)
+                self.c.unsetopt(pycurl.CUSTOMREQUEST)
 
         else:
             self.c.perform()
@@ -217,6 +234,7 @@ class HTTPRequest():
     def verifyHeader(self):
         """ raise an exceptions on bad headers """
         code = int(self.c.getinfo(pycurl.RESPONSE_CODE))
+        # TODO: raise anyway to be consistent, also rename exception
         if code in bad_headers:
             #404 will NOT raise an exception
             raise BadHeader(code, self.getResponse())
@@ -262,7 +280,7 @@ class HTTPRequest():
             #TODO: html_unescape as default
 
         except LookupError:
-            self.log.debug("No Decoder foung for %s" % encoding)
+            self.log.debug("No Decoder found for %s" % encoding)
         except Exception:
             self.log.debug("Error when decoding string from %s." % encoding)
 
diff --git a/module/network/RequestFactory.py b/module/network/RequestFactory.py
index 5b1528281..1581be9fc 100644
--- a/module/network/RequestFactory.py
+++ b/module/network/RequestFactory.py
@@ -24,38 +24,30 @@ from Bucket import Bucket
 from HTTPRequest import HTTPRequest
 from CookieJar import CookieJar
 
-from XDCCRequest import XDCCRequest
-
 class RequestFactory():
     def __init__(self, core):
         self.lock = Lock()
         self.core = core
         self.bucket = Bucket()
         self.updateBucket()
-        self.cookiejars = {}
 
+    @property
     def iface(self):
         return self.core.config["download"]["interface"]
 
-    def getRequest(self, pluginName, account=None, type="HTTP"):
-        self.lock.acquire()
-
-        if type == "XDCC":
-            return XDCCRequest(proxies=self.getProxies())
-
+    def getRequest(self, pluginName, cj=None):
+        # TODO: mostly obsolete, browser could be removed completely
         req = Browser(self.bucket, self.getOptions())
 
-        if account:
-            cj = self.getCookieJar(pluginName, account)
+        if cj:
             req.setCookieJar(cj)
         else:
             req.setCookieJar(CookieJar(pluginName))
 
-        self.lock.release()
         return req
 
     def getHTTPRequest(self, **kwargs):
-        """ returns a http request, dont forget to close it ! """
+        """ returns a http request, don't forget to close it ! """
         options = self.getOptions()
         options.update(kwargs) # submit kwargs as additional options
         return HTTPRequest(CookieJar(None), options)
@@ -67,16 +59,12 @@ class RequestFactory():
             rep = h.load(*args, **kwargs)
         finally:
             h.close()
-            
-        return rep
 
-    def getCookieJar(self, pluginName, account=None):
-        if (pluginName, account) in self.cookiejars:
-            return self.cookiejars[(pluginName, account)]
+        return rep
 
-        cj = CookieJar(pluginName, account)
-        self.cookiejars[(pluginName, account)] = cj
-        return cj
+    def openCookieJar(self, pluginname):
+        """Create new CookieJar"""
+        return CookieJar(pluginname)
 
     def getProxies(self):
         """ returns a proxy list for the request classes """
@@ -106,7 +94,7 @@ class RequestFactory():
 
     def getOptions(self):
         """returns options needed for pycurl"""
-        return {"interface": self.iface(),
+        return {"interface": self.iface,
                 "proxies": self.getProxies(),
                 "ipv6": self.core.config["download"]["ipv6"]}
 
diff --git a/module/network/XDCCRequest.py b/module/network/XDCCRequest.py
index f03798c17..7a1a98cb5 100644
--- a/module/network/XDCCRequest.py
+++ b/module/network/XDCCRequest.py
@@ -119,7 +119,7 @@ class XDCCRequest():
             
             fh.write(data)
             
-            # acknowledge data by sending number of recceived bytes
+            # acknowledge data by sending number of received bytes
             dccsock.send(struct.pack('!I', self.recv))
         
         dccsock.close()
diff --git a/module/plugins/Account.py b/module/plugins/Account.py
index c147404e0..7c24298e7 100644
--- a/module/plugins/Account.py
+++ b/module/plugins/Account.py
@@ -1,292 +1,288 @@
 # -*- coding: utf-8 -*-
 
-"""
-    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/>.
-    
-    @author: mkaay
-"""
-
-from random import choice
 from time import time
 from traceback import print_exc
 from threading import RLock
 
-from Plugin import Base
-from module.utils import compare_time, parseFileSize, lock
+from module.utils import compare_time, format_size, parseFileSize, lock, from_string
+from module.Api import AccountInfo
+from module.network.CookieJar import CookieJar
+
+from Base import Base
 
 class WrongPassword(Exception):
     pass
 
-
-class Account(Base):
+#noinspection PyUnresolvedReferences
+class Account(Base, AccountInfo):
     """
-    Base class for every Account plugin.
-    Just overwrite `login` and cookies will be stored and account becomes accessible in\
-    associated hoster plugin. Plugin should also provide `loadAccountInfo`
+    Base class for every account plugin.
+    Just overwrite `login` and cookies will be stored and the account becomes accessible in\
+    associated hoster plugin. Plugin should also provide `loadAccountInfo`. \
+    An instance of this class is created for every entered account, it holds all \
+    fields of AccountInfo ttype, and can be set easily at runtime.
     """
-    __name__ = "Account"
-    __version__ = "0.2"
-    __type__ = "account"
-    __description__ = """Account Plugin"""
-    __author_name__ = ("mkaay")
-    __author_mail__ = ("mkaay@mkaay.de")
+
+    # constants for special values
+    UNKNOWN = -1
+    UNLIMITED = -2
+
+    # Default values
+    valid = True
+    validuntil = -1
+    trafficleft = -1
+    maxtraffic = -1
+    premium = True
+    activated = True
 
     #: after that time [in minutes] pyload will relogin the account
     login_timeout = 600
     #: account data will be reloaded after this time
     info_threshold = 600
 
+    # known options
+    known_opt = ("time", "limitDL")
 
-    def __init__(self, manager, accounts):
+    def __init__(self, manager, loginname, password, options):
         Base.__init__(self, manager.core)
 
+        if "activated" in options:
+            activated = from_string(options["activated"], "bool")
+        else:
+            activated = Account.activated
+
+        for opt in self.known_opt:
+            if opt not in options:
+                options[opt] = ""
+
+        for opt in options.keys():
+            if opt not in self.known_opt:
+                del options[opt]
+
+        # default account attributes
+        AccountInfo.__init__(self, self.__name__, loginname, Account.valid, Account.validuntil, Account.trafficleft,
+            Account.maxtraffic, Account.premium, activated, options)
+
         self.manager = manager
-        self.accounts = {}
-        self.infos = {} # cache for account information
+
         self.lock = RLock()
+        self.timestamp = 0
+        self.login_ts = 0 # timestamp for login
+        self.cj = CookieJar(self.__name__)
+        self.password = password
+        self.error = None
 
-        self.timestamps = {}
-        self.setAccounts(accounts)
         self.init()
 
     def init(self):
         pass
 
-    def login(self, user, data, req):
-        """login into account, the cookies will be saved so user can be recognized
+    def login(self, req):
+        """login into account, the cookies will be saved so the user can be recognized
 
-        :param user: loginname
-        :param data: data dictionary
         :param req: `Request` instance
         """
-        pass
+        raise NotImplemented
+
+    def relogin(self):
+        """ Force a login. """
+        req = self.getAccountRequest()
+        try:
+            return self._login(req)
+        finally:
+            req.close()
 
     @lock
-    def _login(self, user, data):
+    def _login(self, req):
         # set timestamp for login
-        self.timestamps[user] = time()
-        
-        req = self.getAccountRequest(user)
+        self.login_ts = time()
+
         try:
-            self.login(user, data, req)
+            try:
+                self.login(req)
+            except TypeError: #TODO: temporary
+                self.logDebug("Deprecated .login(...) signature omit user, data")
+                self.login(self.loginname, {"password": self.password}, req)
+
+                
+            self.valid = True
         except WrongPassword:
             self.logWarning(
-                _("Could not login with account %(user)s | %(msg)s") % {"user": user
-                                                                        , "msg": _("Wrong Password")})
-            data["valid"] = False
+                _("Could not login with account %(user)s | %(msg)s") % {"user": self.loginname
+                    , "msg": _("Wrong Password")})
+            self.valid = False
 
         except Exception, e:
             self.logWarning(
-                _("Could not login with account %(user)s | %(msg)s") % {"user": user
-                                                                        , "msg": e})
-            data["valid"] = False
+                _("Could not login with account %(user)s | %(msg)s") % {"user": self.loginname
+                    , "msg": e})
+            self.valid = False
             if self.core.debug:
                 print_exc()
-        finally:
-            if req: req.close()
 
-    def relogin(self, user):
-        req = self.getAccountRequest(user)
-        if req:
-            req.cj.clear()
-            req.close()
-        if user in self.infos:
-            del self.infos[user] #delete old information
-
-        self._login(user, self.accounts[user])
-
-    def setAccounts(self, accounts):
-        self.accounts = accounts
-        for user, data in self.accounts.iteritems():
-            self._login(user, data)
-            self.infos[user] = {}
-
-    def updateAccounts(self, user, password=None, options={}):
-        """ updates account and return true if anything changed """
-
-        if user in self.accounts:
-            self.accounts[user]["valid"] = True #do not remove or accounts will not login
-            if password:
-                self.accounts[user]["password"] = password
-                self.relogin(user)
-                return True
-            if options:
-                before = self.accounts[user]["options"]
-                self.accounts[user]["options"].update(options)
-                return self.accounts[user]["options"] != before
-        else:
-            self.accounts[user] = {"password": password, "options": options, "valid": True}
-            self._login(user, self.accounts[user])
+        return self.valid
+
+    def restoreDefaults(self):
+        self.validuntil = Account.validuntil
+        self.trafficleft = Account.trafficleft
+        self.maxtraffic = Account.maxtraffic
+        self.premium = Account.premium
+
+    def update(self, password=None, options=None):
+        """ updates the account and returns true if anything changed """
+
+        self.login_ts = 0
+        self.valid = True #set valid, so the login will be retried
+
+        if "activated" in options:
+            self.activated = from_string(options["avtivated"], "bool")
+
+        if password:
+            self.password = password
+            self.relogin()
             return True
+        if options:
+            # remove unknown options
+            for opt in options.keys():
+                if opt not in self.known_opt:
+                    del options[opt]
+
+            before = self.options
+            self.options.update(options)
+            return self.options != before
+
+    def getAccountRequest(self):
+        return self.core.requestFactory.getRequest(self.__name__, self.cj)
 
-    def removeAccount(self, user):
-        if user in self.accounts:
-            del self.accounts[user]
-        if user in self.infos:
-            del self.infos[user]
-        if user in self.timestamps:
-            del self.timestamps[user]
+    def getDownloadSettings(self):
+        """ Can be overwritten to change download settings. Default is no chunkLimit, max dl limit, resumeDownload
+
+        :return: (chunkLimit, limitDL, resumeDownload) / (int, int ,bool)
+        """
+        return -1, 0, True
 
     @lock
-    def getAccountInfo(self, name, force=False):
-        """retrieve account infos for an user, do **not** overwrite this method!\\
-        just use it to retrieve infos in hoster plugins. see `loadAccountInfo`
+    def getAccountInfo(self, force=False):
+        """retrieve account info's for an user, do **not** overwrite this method!\\
+        just use it to retrieve info's in hoster plugins. see `loadAccountInfo`
 
         :param name: username
         :param force: reloads cached account information
         :return: dictionary with information
         """
-        data = Account.loadAccountInfo(self, name)
-
-        if force or name not in self.infos:
-            self.logDebug("Get Account Info for %s" % name)
-            req = self.getAccountRequest(name)
+        if force or self.timestamp + self.info_threshold * 60 < time():
 
+            # make sure to login
+            req = self.getAccountRequest()
+            self.checkLogin(req)
+            self.logDebug("Get Account Info for %s" % self.loginname)
             try:
-                infos = self.loadAccountInfo(name, req)
-                if not type(infos) == dict:
-                    raise Exception("Wrong return format")
+                try:
+                    infos = self.loadAccountInfo(req)
+                except TypeError: #TODO: temporary
+                    self.logDebug("Deprecated .loadAccountInfo(...) signature, omit user argument.")
+                    infos = self.loadAccountInfo(self.loginname, req)
             except Exception, e:
                 infos = {"error": str(e)}
-
-            if req: req.close()
+            finally:
+                req.close()
 
             self.logDebug("Account Info: %s" % str(infos))
-
-            infos["timestamp"] = time()
-            self.infos[name] = infos
-        elif "timestamp" in self.infos[name] and self.infos[name][
-                                                       "timestamp"] + self.info_threshold * 60 < time():
-            self.logDebug("Reached timeout for account data")
-            self.scheduleRefresh(name)
-
-        data.update(self.infos[name])
-        return data
-
-    def isPremium(self, user):
-        info = self.getAccountInfo(user)
-        return info["premium"]
-
-    def loadAccountInfo(self, name, req=None):
-        """this should be overwritten in account plugin,\
-        and retrieving account information for user
-
-        :param name:
-        :param req: `Request` instance
+            self.timestamp = time()
+
+            self.restoreDefaults() # reset to initial state
+            if type(infos) == dict: # copy result from dict to class
+                for k, v in infos.iteritems():
+                    if hasattr(self, k):
+                        setattr(self, k, v)
+                    else:
+                        self.logDebug("Unknown attribute %s=%s" % (k, v))
+
+    #TODO: remove user
+    def loadAccountInfo(self, req):
+        """ Overwrite this method and set account attributes within this method.
+
+        :param user: Deprecated
+        :param req: Request instance
         :return:
         """
-        return {
-            "validuntil": None, # -1 for unlimited
-            "login": name,
-            #"password": self.accounts[name]["password"], #@XXX: security
-            "options": self.accounts[name]["options"],
-            "valid": self.accounts[name]["valid"],
-            "trafficleft": None, # in kb, -1 for unlimited
-            "maxtraffic": None,
-            "premium": True, #useful for free accounts
-            "timestamp": 0, #time this info was retrieved
-            "type": self.__name__,
-            }
-
-    def getAllAccounts(self, force=False):
-        return [self.getAccountInfo(user, force) for user, data in self.accounts.iteritems()]
-
-    def getAccountRequest(self, user=None):
-        if not user:
-            user, data = self.selectAccount()
-        if not user:
-            return None
-
-        req = self.core.requestFactory.getRequest(self.__name__, user)
-        return req
-
-    def getAccountCookies(self, user=None):
-        if not user:
-            user, data = self.selectAccount()
-        if not user:
-            return None
-
-        cj = self.core.requestFactory.getCookieJar(self.__name__, user)
-        return cj
-
-    def getAccountData(self, user):
-        return self.accounts[user]
+        pass
 
-    def selectAccount(self):
-        """ returns an valid account name and data"""
-        usable = []
-        for user, data in self.accounts.iteritems():
-            if not data["valid"]: continue
+    def getAccountCookies(self, user):
+        self.logDebug("Deprecated method .getAccountCookies -> use account.cj")
+        return self.cj
 
-            if "time" in data["options"] and data["options"]["time"]:
-                time_data = ""
-                try:
-                    time_data = data["options"]["time"][0]
-                    start, end = time_data.split("-")
-                    if not compare_time(start.split(":"), end.split(":")):
-                        continue
-                except:
-                    self.logWarning(_("Your Time %s has wrong format, use: 1:22-3:44") % time_data)
+    def getAccountData(self, user):
+        self.logDebug("Deprecated method .getAccountData -> use fields directly")
+        return {"password": self.password}
 
-            if user in self.infos:
-                if "validuntil" in self.infos[user]:
-                    if self.infos[user]["validuntil"] > 0 and time() > self.infos[user]["validuntil"]:
-                        continue
-                if "trafficleft" in self.infos[user]:
-                    if self.infos[user]["trafficleft"] == 0:
-                        continue
+    def isPremium(self, user=None):
+        if user: self.logDebug("Deprecated Argument user for .isPremium()", user)
+        return self.premium
 
-            usable.append((user, data))
+    def isUsable(self):
+        """Check several constraints to determine if account should be used"""
+        if not self.valid or not self.activated: return False
 
-        if not usable: return None, None
-        return choice(usable)
+        if self.options["time"]:
+            time_data = ""
+            try:
+                time_data = self.options["time"]
+                start, end = time_data.split("-")
+                if not compare_time(start.split(":"), end.split(":")):
+                    return False
+            except:
+                self.logWarning(_("Your Time %s has a wrong format, use: 1:22-3:44") % time_data)
+
+        if 0 <= self.validuntil < time():
+            return False
+        if self.trafficleft is 0:  # test explicitly for 0
+            return False
 
-    def canUse(self):
-        return False if self.selectAccount() == (None, None) else True
+        return True
 
     def parseTraffic(self, string): #returns kbyte
         return parseFileSize(string) / 1024
 
+    def formatTrafficleft(self):
+        if self.trafficleft is None:
+            self.getAccountInfo(force=True)
+        return format_size(self.trafficleft*1024)
+
     def wrongPassword(self):
         raise WrongPassword
 
-    def empty(self, user):
-        if user in self.infos:
-            self.logWarning(_("Account %s has not enough traffic, checking again in 30min") % user)
+    def empty(self, user=None):
+        if user: self.logDebug("Deprecated argument user for .empty()", user)
+
+        self.logWarning(_("Account %s has not enough traffic, checking again in 30min") % self.login)
+
+        self.trafficleft = 0
+        self.scheduleRefresh(30 * 60)
 
-            self.infos[user].update({"trafficleft": 0})
-            self.scheduleRefresh(user, 30 * 60)
+    def expired(self, user=None):
+        if user: self.logDebug("Deprecated argument user for .expired()", user)
 
-    def expired(self, user):
-        if user in self.infos:
-            self.logWarning(_("Account %s is expired, checking again in 1h") % user)
+        self.logWarning(_("Account %s is expired, checking again in 1h") % user)
 
-            self.infos[user].update({"validuntil": time() - 1})
-            self.scheduleRefresh(user, 60 * 60)
+        self.validuntil = time() - 1
+        self.scheduleRefresh(60 * 60)
 
-    def scheduleRefresh(self, user, time=0, force=True):
-        """ add task to refresh account info to sheduler """
-        self.logDebug("Scheduled Account refresh for %s in %s seconds." % (user, time))
-        self.core.scheduler.addJob(time, self.getAccountInfo, [user, force])
+    def scheduleRefresh(self, time=0, force=True):
+        """ add a task for refreshing the account info to the scheduler """
+        self.logDebug("Scheduled Account refresh for %s in %s seconds." % (self.loginname, time))
+        self.core.scheduler.addJob(time, self.getAccountInfo, [force])
 
     @lock
-    def checkLogin(self, user):
-        """ checks if user is still logged in """
-        if user in self.timestamps:
-            if self.timestamps[user] + self.login_timeout * 60 < time():
-                self.logDebug("Reached login timeout for %s" % user)
-                self.relogin(user)
-                return False
+    def checkLogin(self, req):
+        """ checks if the user is still logged in """
+        if self.login_ts + self.login_timeout * 60 < time():
+            if self.login_ts: # separate from fresh login to have better debug logs
+                self.logDebug("Reached login timeout for %s" % self.loginname)
+            else:
+                self.logDebug("Login with %s" % self.loginname)
+
+            self._login(req)
+            return False
 
         return True
diff --git a/module/plugins/AccountManager.py b/module/plugins/AccountManager.py
deleted file mode 100644
index fc521d36c..000000000
--- a/module/plugins/AccountManager.py
+++ /dev/null
@@ -1,185 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""
-    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/>.
-
-    @author: RaNaN
-"""
-
-from os.path import exists
-from shutil import copy
-
-from threading import Lock
-
-from module.PullEvents import AccountUpdateEvent
-from module.utils import chmod, lock
-
-ACC_VERSION = 1
-
-class AccountManager():
-    """manages all accounts"""
-
-    #----------------------------------------------------------------------
-    def __init__(self, core):
-        """Constructor"""
-
-        self.core = core
-        self.lock = Lock()
-
-        self.initPlugins()
-        self.saveAccounts() # save to add categories to conf
-
-    def initPlugins(self):
-        self.accounts = {} # key = ( plugin )
-        self.plugins = {}
-
-        self.initAccountPlugins()
-        self.loadAccounts()
-
-
-    def getAccountPlugin(self, plugin):
-        """get account instance for plugin or None if anonymous"""
-        if plugin in self.accounts:
-            if plugin not in self.plugins:
-                self.plugins[plugin] = self.core.pluginManager.loadClass("accounts", plugin)(self, self.accounts[plugin])
-
-            return self.plugins[plugin]
-        else:
-            return None
-
-    def getAccountPlugins(self):
-        """ get all account instances"""
-        
-        plugins = []
-        for plugin in self.accounts.keys():
-            plugins.append(self.getAccountPlugin(plugin))
-            
-        return plugins
-    #----------------------------------------------------------------------
-    def loadAccounts(self):
-        """loads all accounts available"""
-        
-        if not exists("accounts.conf"):
-            f = open("accounts.conf", "wb")
-            f.write("version: " + str(ACC_VERSION))
-            f.close()
-            
-        f = open("accounts.conf", "rb")
-        content = f.readlines()
-        version = content[0].split(":")[1].strip() if content else ""
-        f.close()
-
-        if not version or int(version) < ACC_VERSION:
-            copy("accounts.conf", "accounts.backup")
-            f = open("accounts.conf", "wb")
-            f.write("version: " + str(ACC_VERSION))
-            f.close()
-            self.core.log.warning(_("Account settings deleted, due to new config format."))
-            return
-            
-            
-        
-        plugin = ""
-        name = ""
-        
-        for line in content[1:]:
-            line = line.strip()
-            
-            if not line: continue
-            if line.startswith("#"): continue
-            if line.startswith("version"): continue
-            
-            if line.endswith(":") and line.count(":") == 1:
-                plugin = line[:-1]
-                self.accounts[plugin] = {}
-                
-            elif line.startswith("@"):
-                try:
-                    option = line[1:].split()
-                    self.accounts[plugin][name]["options"][option[0]] = [] if len(option) < 2 else ([option[1]] if len(option) < 3 else option[1:])
-                except:
-                    pass
-                
-            elif ":" in line:
-                name, sep, pw = line.partition(":")
-                self.accounts[plugin][name] = {"password": pw, "options": {}, "valid": True}
-    #----------------------------------------------------------------------
-    def saveAccounts(self):
-        """save all account information"""
-        
-        f = open("accounts.conf", "wb")
-        f.write("version: " + str(ACC_VERSION) + "\n")
-                
-        for plugin, accounts in self.accounts.iteritems():
-            f.write("\n")
-            f.write(plugin+":\n")
-            
-            for name,data in accounts.iteritems():
-                f.write("\n\t%s:%s\n" % (name,data["password"]) )
-                if data["options"]:
-                    for option, values in data["options"].iteritems():
-                        f.write("\t@%s %s\n" % (option, " ".join(values)))
-                    
-        f.close()
-        chmod(f.name, 0600)
-            
-        
-    #----------------------------------------------------------------------
-    def initAccountPlugins(self):
-        """init names"""
-        for name in self.core.pluginManager.getAccountPlugins():
-            self.accounts[name] = {}
-        
-    @lock
-    def updateAccount(self, plugin , user, password=None, options={}):
-        """add or update account"""
-        if plugin in self.accounts:
-            p = self.getAccountPlugin(plugin)
-            updated = p.updateAccounts(user, password, options)
-            #since accounts is a ref in plugin self.accounts doesnt need to be updated here
-                    
-            self.saveAccounts()
-            if updated: p.scheduleRefresh(user, force=False)
-                
-    @lock
-    def removeAccount(self, plugin, user):
-        """remove account"""
-        
-        if plugin in self.accounts:
-            p = self.getAccountPlugin(plugin)
-            p.removeAccount(user)
-
-            self.saveAccounts()
-
-    @lock
-    def getAccountInfos(self, force=True, refresh=False):
-        data = {}
-
-        if refresh:
-            self.core.scheduler.addJob(0, self.core.accountManager.getAccountInfos)
-            force = False
-        
-        for p in self.accounts.keys():
-            if self.accounts[p]:
-                p = self.getAccountPlugin(p)
-                data[p.__name__] = p.getAllAccounts(force)
-            else:
-                data[p] = []
-        e = AccountUpdateEvent()
-        self.core.pullManager.addEvent(e)
-        return data
-    
-    def sendChange(self):
-        e = AccountUpdateEvent()
-        self.core.pullManager.addEvent(e)
diff --git a/module/plugins/Addon.py b/module/plugins/Addon.py
new file mode 100644
index 000000000..ff9c57bef
--- /dev/null
+++ b/module/plugins/Addon.py
@@ -0,0 +1,205 @@
+# -*- coding: utf-8 -*-
+
+"""
+    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/>.
+    
+    @author: RaNaN
+"""
+
+from traceback import print_exc
+
+#from functools import wraps
+from module.utils import has_method, to_list
+
+from Base import Base
+
+def class_name(p):
+    return p.rpartition(".")[2]
+
+
+def AddEventListener(event):
+    """ Used to register method for events. Arguments needs to match parameter of event
+
+    :param event: Name of event or list of them.
+    """
+    class _klass(object):
+        def __new__(cls, f, *args, **kwargs):
+            for ev in to_list(event):
+                addonManager.addEventListener(class_name(f.__module__), f.func_name, ev)
+            return f
+    return _klass
+
+class ConfigHandler(object):
+    """ Register method as config handler.
+
+    Your method signature has to be:
+        def foo(value=None):
+
+    value will be passed to use your method to set the config.
+    When value is None your method needs to return an interaction task for configuration.
+    """
+
+    def __new__(cls, f, *args, **kwargs):
+        addonManager.addConfigHandler(class_name(f.__module__), f.func_name)
+        return f
+
+def AddonHandler(desc, media=None):
+    """ Register Handler for files, packages, or arbitrary callable methods.
+        To let the method work on packages/files, media must be set and the argument named pid or fid.
+
+    :param desc: verbose description
+    :param media: if True or bits of media type
+    """
+    pass
+
+def AddonInfo(desc):
+    """ Called to retrieve information about the current state.
+    Decorated method must return anything convertable into string.
+
+    :param desc: verbose description
+    """
+    pass
+
+def threaded(f):
+    """ Decorator to run method in a thread. """
+
+    #@wraps(f)
+    def run(*args,**kwargs):
+        addonManager.startThread(f, *args, **kwargs)
+    return run
+
+class Addon(Base):
+    """
+    Base class for addon plugins. Use @threaded decorator for all longer running tasks.
+
+    Decorate methods with @Expose, @AddEventListener, @ConfigHandler
+
+    """
+
+    #: automatically register event listeners for functions, attribute will be deleted don't use it yourself
+    event_map = None
+
+    # Alternative to event_map
+    #: List of events the plugin can handle, name the functions exactly like eventname.
+    event_list = None  # dont make duplicate entries in event_map
+
+    #: periodic call interval in seconds
+    interval = 60
+
+    def __init__(self, core, manager, user=None):
+        Base.__init__(self, core, user)
+
+        #: Provide information in dict here, usable by API `getInfo`
+        self.info = None
+
+        #: Callback of periodical job task, used by addonmanager
+        self.cb = None
+
+        #: `AddonManager`
+        self.manager = manager
+
+        #register events
+        if self.event_map:
+            for event, funcs in self.event_map.iteritems():
+                if type(funcs) in (list, tuple):
+                    for f in funcs:
+                        self.evm.addEvent(event, getattr(self,f))
+                else:
+                    self.evm.addEvent(event, getattr(self,funcs))
+
+            #delete for various reasons
+            self.event_map = None
+
+        if self.event_list:
+            for f in self.event_list:
+                self.evm.addEvent(f, getattr(self,f))
+
+            self.event_list = None
+
+        self.initPeriodical()
+        self.init()
+        self.setup()
+
+    def initPeriodical(self):
+        if self.interval >=1:
+            self.cb = self.core.scheduler.addJob(0, self._periodical, threaded=False)
+
+    def _periodical(self):
+        try:
+            if self.isActivated(): self.periodical()
+        except Exception, e:
+            self.core.log.error(_("Error executing addons: %s") % str(e))
+            if self.core.debug:
+                print_exc()
+
+        self.cb = self.core.scheduler.addJob(self.interval, self._periodical, threaded=False)
+
+    def __repr__(self):
+        return "<Addon %s>" % self.__name__
+
+    def isActivated(self):
+        """ checks if addon is activated"""
+        return True if self.__internal__ else self.getConfig("activated")
+
+    def getCategory(self):
+        return self.core.pluginManager.getCategory(self.__name__)
+
+    def init(self):
+        pass
+
+    def setup(self):
+        """ more init stuff if needed """
+        pass
+
+    def activate(self):
+        """  Used to activate the addon """
+        if has_method(self.__class__, "coreReady"):
+            self.logDebug("Deprecated method .coreReady() use activate() instead")
+            self.coreReady()
+
+    def deactivate(self):
+        """ Used to deactivate the addon. """
+        pass
+
+    def periodical(self):
+        pass
+
+    def newInteractionTask(self, task):
+        """ new interaction task for the plugin, it MUST set the handler and timeout or will be ignored """
+        pass
+
+    def taskCorrect(self, task):
+        pass
+
+    def taskInvalid(self, task):
+        pass
+
+    # public events starts from here
+    def downloadPreparing(self, pyfile):
+        pass
+    
+    def downloadFinished(self, pyfile):
+        pass
+
+    def downloadFailed(self, pyfile):
+        pass
+
+    def packageFinished(self, pypack):
+        pass
+
+    def beforeReconnecting(self, ip):
+        pass
+    
+    def afterReconnecting(self, ip):
+        pass
\ No newline at end of file
diff --git a/module/plugins/Base.py b/module/plugins/Base.py
new file mode 100644
index 000000000..70805b7f3
--- /dev/null
+++ b/module/plugins/Base.py
@@ -0,0 +1,339 @@
+# -*- coding: utf-8 -*-
+
+"""
+    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/>.
+
+    @author: RaNaN
+"""
+
+import sys
+from time import time, sleep
+from random import randint
+
+from module.utils import decode
+from module.utils.fs import exists, makedirs, join, remove
+
+# TODO
+#       more attributes if needed
+#       get rid of catpcha & container plugins ?! (move to crypter & internals)
+#       adapt old plugins as needed
+
+class Fail(Exception):
+    """ raised when failed """
+
+class Retry(Exception):
+    """ raised when start again from beginning """
+
+class Abort(Exception):
+    """ raised when aborted """
+
+class Base(object):
+    """
+    The Base plugin class with all shared methods and every possible attribute for plugin definition.
+    """
+    __version__ = "0.1"
+    #: Regexp pattern which will be matched for download/crypter plugins
+    __pattern__ = r""
+    #: Internal addon plugin which is always loaded
+    __internal__ = False
+    #: When True this addon can be enabled by every user
+    __user_context__ = False
+    #: Config definition: list of  (name, type, label, default_value) or
+    #: (name, type, label, short_description, default_value)
+    __config__ = list()
+    #: Short description, one liner
+    __label__ = ""
+    #: More detailed text
+    __description__ = """"""
+    #: List of needed modules
+    __dependencies__ = tuple()
+    #: Used to assign a category for addon plugins
+    __category__ = ""
+    #: Tags to categorize the plugin, see documentation for further info
+    __tags__ = tuple()
+    #: Base64 encoded .png icon, should be 32x32, please don't use sizes above ~2KB, for bigger icons use url.
+    __icon__ = ""
+    #: Alternative, link to png icon
+    __icon_url__ = ""
+    #: Url with general information/support/discussion
+    __url__ = ""
+    #: Url to term of content, user is accepting these when using the plugin
+    __toc_url__ = ""
+    #: Url to service (to buy premium) for accounts
+    __ref_url__ = ""
+
+    __author_name__ = tuple()
+    __author_mail__ = tuple()
+
+
+    def __init__(self, core, user=None):
+        self.__name__ = self.__class__.__name__
+
+        #: Core instance
+        self.core = core
+        #: logging instance
+        self.log = core.log
+        #: core config
+        self.config = core.config
+        #: :class:`EventManager`
+        self.evm = core.eventManager
+        #: :class:`InteractionManager`
+        self.im = core.interactionManager
+        if user:
+            #: :class:`Api`, user api when user is set
+            self.api = self.core.api.withUserContext(user)
+            if self.api:
+                #: :class:`User`, user related to this plugin
+                self.user = self.api.user
+            else:
+                self.api = self.core.api
+                self.user = None
+        else:
+            self.api = self.core.api
+            self.user = None
+
+        #: last interaction task
+        self.task = None
+
+    def logInfo(self, *args, **kwargs):
+        """ Print args to log at specific level
+
+        :param args: Arbitrary object which should be logged
+        :param kwargs: sep=(how to separate arguments), default = " | "
+        """
+        self._log("info", *args, **kwargs)
+
+    def logWarning(self, *args, **kwargs):
+        self._log("warning", *args, **kwargs)
+
+    def logError(self, *args, **kwargs):
+        self._log("error", *args, **kwargs)
+
+    def logDebug(self, *args, **kwargs):
+        self._log("debug", *args, **kwargs)
+
+    def _log(self, level, *args, **kwargs):
+        if "sep" in kwargs:
+            sep = "%s" % kwargs["sep"]
+        else:
+            sep = " | "
+
+        strings = []
+        for obj in args:
+            if type(obj) == unicode:
+                strings.append(obj)
+            elif type(obj) == str:
+                strings.append(decode(obj))
+            else:
+                strings.append(str(obj))
+
+        getattr(self.log, level)("%s: %s" % (self.__name__, sep.join(strings)))
+
+    def setConfig(self, option, value):
+        """ Set config value for current plugin """
+        self.core.config.set(self.__name__, option, value)
+
+    def getConf(self, option):
+        """ see `getConfig` """
+        return self.core.config.get(self.__name__, option)
+
+    def getConfig(self, option):
+        """ Returns config value for current plugin """
+        return self.getConf(option)
+
+    def setStorage(self, key, value):
+        """ Saves a value persistently to the database """
+        self.core.db.setStorage(self.__name__, key, value)
+
+    def store(self, key, value):
+        """ same as `setStorage` """
+        self.core.db.setStorage(self.__name__, key, value)
+
+    def getStorage(self, key=None, default=None):
+        """ Retrieves saved value or dict of all saved entries if key is None """
+        if key is not None:
+            return self.core.db.getStorage(self.__name__, key) or default
+        return self.core.db.getStorage(self.__name__, key)
+
+    def retrieve(self, *args, **kwargs):
+        """ same as `getStorage` """
+        return self.getStorage(*args, **kwargs)
+
+    def delStorage(self, key):
+        """ Delete entry in db """
+        self.core.db.delStorage(self.__name__, key)
+
+    def shell(self):
+        """ open ipython shell """
+        if self.core.debug:
+            from IPython import embed
+            #noinspection PyUnresolvedReferences
+            sys.stdout = sys._stdout
+            embed()
+
+    def abort(self):
+        """ Check if plugin is in an abort state, is overwritten by subtypes"""
+        return False
+
+    def checkAbort(self):
+        """  Will be overwritten to determine if control flow should be aborted """
+        if self.abort(): raise Abort()
+
+    def load(self, url, get={}, post={}, ref=True, cookies=True, just_header=False, decode=False):
+        """Load content at url and returns it
+
+        :param url: url as string
+        :param get: GET as dict
+        :param post: POST as dict, list or string
+        :param ref: Set HTTP_REFERER header
+        :param cookies: use saved cookies
+        :param just_header: if True only the header will be retrieved and returned as dict
+        :param decode: Whether to decode the output according to http header, should be True in most cases
+        :return: Loaded content
+        """
+        if not hasattr(self, "req"): raise Exception("Plugin type does not have Request attribute.")
+        self.checkAbort()
+
+        res = self.req.load(url, get, post, ref, cookies, just_header, decode=decode)
+
+        if self.core.debug:
+            from inspect import currentframe
+
+            frame = currentframe()
+            if not exists(join("tmp", self.__name__)):
+                makedirs(join("tmp", self.__name__))
+
+            f = open(
+                join("tmp", self.__name__, "%s_line%s.dump.html" % (frame.f_back.f_code.co_name, frame.f_back.f_lineno))
+                , "wb")
+            del frame # delete the frame or it wont be cleaned
+
+            try:
+                tmp = res.encode("utf8")
+            except:
+                tmp = res
+
+            f.write(tmp)
+            f.close()
+
+        if just_header:
+            #parse header
+            header = {"code": self.req.code}
+            for line in res.splitlines():
+                line = line.strip()
+                if not line or ":" not in line: continue
+
+                key, none, value = line.partition(":")
+                key = key.lower().strip()
+                value = value.strip()
+
+                if key in header:
+                    if type(header[key]) == list:
+                        header[key].append(value)
+                    else:
+                        header[key] = [header[key], value]
+                else:
+                    header[key] = value
+            res = header
+
+        return res
+
+    def invalidTask(self):
+        if self.task:
+            self.task.invalid()
+
+    def invalidCaptcha(self):
+        self.logDebug("Deprecated method .invalidCaptcha, use .invalidTask")
+        self.invalidTask()
+
+    def correctTask(self):
+        if self.task:
+            self.task.correct()
+
+    def correctCaptcha(self):
+        self.logDebug("Deprecated method .correctCaptcha, use .correctTask")
+        self.correctTask()
+
+    def decryptCaptcha(self, url, get={}, post={}, cookies=False, forceUser=False, imgtype='jpg',
+                       result_type='textual'):
+        """ Loads a captcha and decrypts it with ocr, plugin, user input
+
+        :param url: url of captcha image
+        :param get: get part for request
+        :param post: post part for request
+        :param cookies: True if cookies should be enabled
+        :param forceUser: if True, ocr is not used
+        :param imgtype: Type of the Image
+        :param result_type: 'textual' if text is written on the captcha\
+        or 'positional' for captcha where the user have to click\
+        on a specific region on the captcha
+
+        :return: result of decrypting
+        """
+
+        img = self.load(url, get=get, post=post, cookies=cookies)
+
+        id = ("%.2f" % time())[-6:].replace(".", "")
+        temp_file = open(join("tmp", "tmpCaptcha_%s_%s.%s" % (self.__name__, id, imgtype)), "wb")
+        temp_file.write(img)
+        temp_file.close()
+
+        name = "%sOCR" % self.__name__
+        has_plugin = name in self.core.pluginManager.getPlugins("internal")
+
+        if self.core.captcha:
+            OCR = self.core.pluginManager.loadClass("internal", name)
+        else:
+            OCR = None
+
+        if OCR and not forceUser:
+            sleep(randint(3000, 5000) / 1000.0)
+            self.checkAbort()
+
+            ocr = OCR()
+            result = ocr.get_captcha(temp_file.name)
+        else:
+            task = self.im.createCaptchaTask(img, imgtype, temp_file.name, self.__name__, result_type)
+            self.task = task
+
+            while task.isWaiting():
+                if self.abort():
+                    self.im.removeTask(task)
+                    raise Abort()
+                sleep(1)
+
+            #TODO task handling
+            self.im.removeTask(task)
+
+            if task.error and has_plugin: #ignore default error message since the user could use OCR
+                self.fail(_("Pil and tesseract not installed and no Client connected for captcha decrypting"))
+            elif task.error:
+                self.fail(task.error)
+            elif not task.result:
+                self.fail(_("No captcha result obtained in appropriate time."))
+
+            result = task.result
+            self.log.debug("Received captcha result: %s" % str(result))
+
+        if not self.core.debug:
+            try:
+                remove(temp_file.name)
+            except:
+                pass
+
+        return result
+
+    def fail(self, reason):
+        """ fail and give reason """
+        raise Fail(reason)
\ No newline at end of file
diff --git a/module/plugins/Container.py b/module/plugins/Container.py
deleted file mode 100644
index c233d3710..000000000
--- a/module/plugins/Container.py
+++ /dev/null
@@ -1,75 +0,0 @@
-# -*- coding: utf-8 -*-
-
-"""
-    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/>.
-    
-    @author: mkaay
-"""
-
-from module.plugins.Crypter import Crypter
-
-from os.path import join, exists, basename
-from os import remove
-import re
-
-class Container(Crypter):
-    __name__ = "Container"
-    __version__ = "0.1"
-    __pattern__ = None
-    __type__ = "container"
-    __description__ = """Base container plugin"""
-    __author_name__ = ("mkaay")
-    __author_mail__ = ("mkaay@mkaay.de")
-
-
-    def preprocessing(self, thread):
-        """prepare"""
-
-        self.setup()
-        self.thread = thread
-        
-        self.loadToDisk()
-
-        self.decrypt(self.pyfile)
-        self.deleteTmp()
-        
-        self.createPackages()
-    
-
-    def loadToDisk(self):
-        """loads container to disk if its stored remotely and overwrite url, 
-        or check existent on several places at disk"""
-        
-        if self.pyfile.url.startswith("http"):
-            self.pyfile.name = re.findall("([^\/=]+)", self.pyfile.url)[-1]
-            content = self.load(self.pyfile.url)
-            self.pyfile.url = join(self.config["general"]["download_folder"], self.pyfile.name)
-            f = open(self.pyfile.url, "wb" )
-            f.write(content)
-            f.close()
-            
-        else:
-            self.pyfile.name = basename(self.pyfile.url)
-            if not exists(self.pyfile.url):
-                if exists(join(pypath, self.pyfile.url)):
-                    self.pyfile.url = join(pypath, self.pyfile.url)
-                else:
-                    self.fail(_("File not exists."))
-      
-
-    def deleteTmp(self):
-        if self.pyfile.name.startswith("tmp_"):
-            remove(self.pyfile.url)
-
-        
diff --git a/module/plugins/Crypter.py b/module/plugins/Crypter.py
index d1549fe80..61370541f 100644
--- a/module/plugins/Crypter.py
+++ b/module/plugins/Crypter.py
@@ -1,72 +1,271 @@
 # -*- coding: utf-8 -*-
 
-"""
-    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/>.
-    
-    @author: mkaay
-"""
-
-from module.plugins.Plugin import Plugin
-
-class Crypter(Plugin):
-    __name__ = "Crypter"
-    __version__ = "0.1"
-    __pattern__ = None
-    __type__ = "container"
-    __description__ = """Base crypter plugin"""
-    __author_name__ = ("mkaay")
-    __author_mail__ = ("mkaay@mkaay.de")
-    
-    def __init__(self, pyfile):
-        Plugin.__init__(self, pyfile)
-        
-        #: Put all packages here. It's a list of tuples like: ( name, [list of links], folder )
-        self.packages = []
+from traceback import print_exc
+
+from module.common.packagetools import parseNames
+from module.utils import to_list, has_method, uniqify
+from module.utils.fs import exists, remove, fs_encode
+
+from Base import Base, Retry
+
+class Package:
+    """ Container that indicates that a new package should be created """
+    def __init__(self, name, urls=None, folder=None):
+        self.name = name
+        self.urls = urls if urls else []
+        self.folder = folder
+
+        # nested packages
+        self.packs = []
+
+    def addURL(self, url):
+        self.urls.append(url)
+
+    def addPackage(self, pack):
+        self.packs.append(pack)
+
+    def getAllURLs(self):
+        urls = self.urls
+        for p in self.packs:
+            urls.extend(p.getAllURLs())
+        return urls
+
+    # same name and urls is enough to be equal for packages
+    def __eq__(self, other):
+        return self.name == other.name and self.urls == other.urls
+
+    def __repr__(self):
+        return u"<CrypterPackage name=%s, links=%s, packs=%s" % (self.name, self.urls, self.packs)
+
+    def __hash__(self):
+        return hash(self.name) ^ hash(frozenset(self.urls)) ^ hash(self.name)
+
+class PyFileMockup:
+    """ Legacy class needed by old crypter plugins """
+    def __init__(self, url, pack):
+        self.url = url
+        self.name = url
+        self._package = pack
+        self.packageid = pack.id if pack else -1
+
+    def package(self):
+        return self._package
+
+class Crypter(Base):
+    """
+    Base class for (de)crypter plugins. Overwrite decrypt* methods.
+
+    How to use decrypt* methods:
+
+    You have to overwrite at least one method of decryptURL, decryptURLs, decryptFile.
+
+    After decrypting and generating urls/packages you have to return the result.
+    Valid return Data is:
+
+    :class:`Package` instance Crypter.Package
+        A **new** package will be created with the name and the urls of the object.
+
+    List of urls and `Package` instances
+        All urls in the list will be added to the **current** package. For each `Package`\
+        instance a new package will be created.
+
+    """
+
+    #: Prefix to annotate that the submited string for decrypting is indeed file content
+    CONTENT_PREFIX = "filecontent:"
+
+    @classmethod
+    def decrypt(cls, core, url_or_urls):
+        """Static method to decrypt urls or content. Can be used by other plugins.
+        To decrypt file content prefix the string with ``CONTENT_PREFIX `` as seen above.
+
+        :param core: pyLoad `Core`, needed in decrypt context
+        :param url_or_urls: List of urls or single url/ file content
+        :return: List of decrypted urls, all package info removed
+        """
+        urls = to_list(url_or_urls)
+        p = cls(core)
+        try:
+            result = p.processDecrypt(urls)
+        finally:
+            p.clean()
+
+        ret = []
+
+        for url_or_pack in result:
+            if isinstance(url_or_pack, Package): #package
+                ret.extend(url_or_pack.getAllURLs())
+            else: # single url
+                ret.append(url_or_pack)
+        # eliminate duplicates
+        return uniqify(ret)
+
+    def __init__(self, core, package=None, password=None):
+        Base.__init__(self, core)
+        self.req = core.requestFactory.getRequest(self.__name__)
+
+        # Package the plugin was initialized for, don't use this, its not guaranteed to be set
+        self.package = package
+        #: Password supplied by user
+        self.password = password
+        #: Propose a renaming of the owner package
+        self.rename = None
 
-        #: List of urls, pyLoad will generate packagenames
+        # For old style decrypter, do not use these!
+        self.packages = []
         self.urls = []
-        
-        self.multiDL = True
-        self.limitDL = 0
-    
-
-    def preprocessing(self, thread):
-        """prepare"""
-        self.setup()
-        self.thread = thread
-
-        self.decrypt(self.pyfile)
-        
-        self.createPackages()
-        
-
-    def decrypt(self, pyfile):
+        self.pyfile = None
+
+        self.init()
+
+    def init(self):
+        """More init stuff if needed"""
+
+    def setup(self):
+        """Called everytime before decrypting. A Crypter plugin will be most likely used for several jobs."""
+
+    def decryptURL(self, url):
+        """Decrypt a single url
+
+        :param url: url to decrypt
+        :return: See :class:`Crypter` Documentation
+        """
+        if url.startswith("http"): # basic method to redirect
+            return self.decryptFile(self.load(url))
+        else:
+            self.fail(_("Not existing file or unsupported protocol"))
+
+    def decryptURLs(self, urls):
+        """Decrypt a bunch of urls
+
+        :param urls: list of urls
+        :return: See :class:`Crypter` Documentation
+        """
         raise NotImplementedError
 
-    def createPackages(self):
-        """ create new packages from self.packages """
-        for pack in self.packages:
+    def decryptFile(self, content):
+        """Decrypt file content
 
-            self.log.debug("Parsed package %(name)s with %(len)d links" % { "name" : pack[0], "len" : len(pack[1]) } )
-            
-            links = [x.decode("utf-8") for x in pack[1]]
-            
-            pid = self.core.api.addPackage(pack[0], links, self.pyfile.package().queue)
+        :param content: content to decrypt as string
+        :return: See :class:`Crypter` Documentation
+        """
+        raise NotImplementedError
+
+    def generatePackages(self, urls):
+        """Generates :class:`Package` instances and names from urls. Useful for many different links and no\
+        given package name.
+
+        :param urls: list of urls
+        :return: list of `Package`
+        """
+        return [Package(name, purls) for name, purls in parseNames([(url,url) for url in urls]).iteritems()]
+
+    def _decrypt(self, urls):
+        """ Internal  method to select decrypting method
+
+        :param urls: List of urls/content
+        :return:
+        """
+        cls = self.__class__
+
+        # separate local and remote files
+        content, urls = self.getLocalContent(urls)
+
+        if has_method(cls, "decryptURLs"):
+            self.setup()
+            result = to_list(self.decryptURLs(urls))
+        elif has_method(cls, "decryptURL"):
+            result = []
+            for url in urls:
+                self.setup()
+                result.extend(to_list(self.decryptURL(url)))
+        elif has_method(cls, "decrypt"):
+            self.logDebug("Deprecated .decrypt() method in Crypter plugin")
+            result = []
+            for url in urls:
+                self.pyfile = PyFileMockup(url, self.package)
+                self.setup()
+                self.decrypt(self.pyfile)
+                result.extend(self.convertPackages())
+        else:
+            if not has_method(cls, "decryptFile") or urls:
+                self.logDebug("No suited decrypting method was overwritten in plugin")
+            result = []
+
+        if has_method(cls, "decryptFile"):
+            for f, c in content:
+                self.setup()
+                result.extend(to_list(self.decryptFile(c)))
+                try:
+                    if f.startswith("tmp_"): remove(f)
+                except :
+                    pass
+
+        return result
+
+    def processDecrypt(self, urls):
+        """Catches all exceptions in decrypt methods and return results
+
+        :return: Decrypting results
+        """
+        try:
+            return self._decrypt(urls)
+        except Exception:
+            if self.core.debug:
+                print_exc()
+            return []
+
+    def getLocalContent(self, urls):
+        """Load files from disk and separate to file content and url list
+
+        :param urls:
+        :return: list of (filename, content), remote urls
+        """
+        content = []
+        # do nothing if no decryptFile method
+        if hasattr(self.__class__, "decryptFile"):
+            remote = []
+            for url in urls:
+                path = None
+                if url.startswith("http"): # skip urls directly
+                    pass
+                elif url.startswith(self.CONTENT_PREFIX):
+                    path = url
+                elif exists(url):
+                    path = url
+                elif exists(self.core.path(url)):
+                    path = self.core.path(url)
+
+                if path:
+                    try:
+                        if path.startswith(self.CONTENT_PREFIX):
+                            content.append(("", path[len(self.CONTENT_PREFIX)]))
+                        else:
+                            f = open(fs_encode(path), "rb")
+                            content.append((f.name, f.read()))
+                            f.close()
+                    except IOError, e:
+                        self.logError("IOError", e)
+                else:
+                    remote.append(url)
+
+            #swap filtered url list
+            urls = remote
+
+        return content, urls
 
-            if self.pyfile.package().password:
-                self.core.api.setPackageData(pid, {"password": self.pyfile.package().password})
+    def retry(self):
+        """ Retry decrypting, will only work once. Somewhat deprecated method, should be avoided. """
+        raise Retry()
 
-        if self.urls:
-            self.core.api.generateAndAddPackages(self.urls)
+    def convertPackages(self):
+        """ Deprecated """
+        self.logDebug("Deprecated method .convertPackages()")
+        res = [Package(name, urls) for name, urls in self.packages]
+        res.extend(self.urls)
+        return res
             
+    def clean(self):
+        if hasattr(self, "req"):
+            self.req.close()
+            del self.req
\ No newline at end of file
diff --git a/module/plugins/Hook.py b/module/plugins/Hook.py
deleted file mode 100644
index 5efd08bae..000000000
--- a/module/plugins/Hook.py
+++ /dev/null
@@ -1,161 +0,0 @@
-# -*- coding: utf-8 -*-
-
-"""
-    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/>.
-    
-    @author: mkaay
-    @interface-version: 0.2
-"""
-
-from traceback import print_exc
-
-from Plugin import Base
-
-class Expose(object):
-    """ used for decoration to declare rpc services """
-
-    def __new__(cls, f, *args, **kwargs):
-        hookManager.addRPC(f.__module__, f.func_name, f.func_doc)
-        return f
-
-def threaded(f):
-    def run(*args,**kwargs):
-        hookManager.startThread(f, *args, **kwargs)
-    return run
-
-class Hook(Base):
-    """
-    Base class for hook plugins.
-    """
-    __name__ = "Hook"
-    __version__ = "0.2"
-    __type__ = "hook"
-    __threaded__ = []
-    __config__ = [ ("name", "type", "desc" , "default") ]
-    __description__ = """interface for hook"""
-    __author_name__ = ("mkaay", "RaNaN")
-    __author_mail__ = ("mkaay@mkaay.de", "RaNaN@pyload.org")
-
-    #: automatically register event listeners for functions, attribute will be deleted dont use it yourself
-    event_map = None
-
-    # Alternative to event_map
-    #: List of events the plugin can handle, name the functions exactly like eventname.
-    event_list = None  # dont make duplicate entries in event_map
-
-
-    #: periodic call interval in secondc
-    interval = 60
-
-    def __init__(self, core, manager):
-        Base.__init__(self, core)
-
-        #: Provide information in dict here, usable by API `getInfo`
-        self.info = None
-
-        #: Callback of periodical job task, used by hookmanager
-        self.cb = None
-
-        #: `HookManager`
-        self.manager = manager
-
-        #register events
-        if self.event_map:
-            for event, funcs in self.event_map.iteritems():
-                if type(funcs) in (list, tuple):
-                    for f in funcs:
-                        self.manager.addEvent(event, getattr(self,f))
-                else:
-                    self.manager.addEvent(event, getattr(self,funcs))
-
-            #delete for various reasons
-            self.event_map = None
-
-        if self.event_list:
-            for f in self.event_list:
-                self.manager.addEvent(f, getattr(self,f))
-
-            self.event_list = None
-
-        self.initPeriodical()
-        self.setup()
-
-    def initPeriodical(self):
-        if self.interval >=1:
-            self.cb = self.core.scheduler.addJob(0, self._periodical, threaded=False)
-
-    def _periodical(self):
-        try:
-            if self.isActivated(): self.periodical()
-        except Exception, e:
-            self.core.log.error(_("Error executing hooks: %s") % str(e))
-            if self.core.debug:
-                print_exc()
-
-        self.cb = self.core.scheduler.addJob(self.interval, self._periodical, threaded=False)
-
-
-    def __repr__(self):
-        return "<Hook %s>" % self.__name__
-               
-    def setup(self):
-        """ more init stuff if needed """
-        pass
-
-    def unload(self):
-        """ called when hook was deactivated """
-        pass
-    
-    def isActivated(self):
-        """ checks if hook is activated"""
-        return self.config.getPlugin(self.__name__, "activated")
-    
-
-    #event methods - overwrite these if needed    
-    def coreReady(self):
-        pass
-
-    def coreExiting(self):
-        pass
-    
-    def downloadPreparing(self, pyfile):
-        pass
-    
-    def downloadFinished(self, pyfile):
-        pass
-    
-    def downloadFailed(self, pyfile):
-        pass
-    
-    def packageFinished(self, pypack):
-        pass
-
-    def beforeReconnecting(self, ip):
-        pass
-    
-    def afterReconnecting(self, ip):
-        pass
-    
-    def periodical(self):
-        pass
-
-    def newCaptchaTask(self, task):
-        """ new captcha task for the plugin, it MUST set the handler and timeout or will be ignored """
-        pass
-
-    def captchaCorrect(self, task):
-        pass
-
-    def captchaInvalid(self, task):
-        pass
\ No newline at end of file
diff --git a/module/plugins/Hoster.py b/module/plugins/Hoster.py
index 814a70949..651471a93 100644
--- a/module/plugins/Hoster.py
+++ b/module/plugins/Hoster.py
@@ -13,21 +13,388 @@
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, see <http://www.gnu.org/licenses/>.
-    
-    @author: mkaay
+
+    @author: RaNaN, spoob, mkaay
 """
 
-from module.plugins.Plugin import Plugin
+import os
+from time import time
+
+if os.name != "nt":
+    from module.utils.fs import chown
+    from pwd import getpwnam
+    from grp import getgrnam
+
+from Base import Base, Fail, Retry
+from module.utils import chunks as _chunks
+from module.utils.fs import save_join, save_filename, fs_encode, fs_decode,\
+    remove, makedirs, chmod, stat, exists, join
+
+# Import for Hoster Plugins
+chunks = _chunks
+
+class Reconnect(Exception):
+    """ raised when reconnected """
+
+class SkipDownload(Exception):
+    """ raised when download should be skipped """
+
+class Hoster(Base):
+    """
+    Base plugin for hoster plugin. Overwrite getInfo for online status retrieval, process for downloading.
+    """
+
+    @staticmethod
+    def getInfo(urls):
+        """This method is used to retrieve the online status of files for hoster plugins.
+        It has to *yield* list of tuples with the result in this format (name, size, status, url),
+        where status is one of API pyfile statuses.
+
+        :param urls: List of urls
+        :return: yield list of tuple with results (name, size, status, url)
+        """
+        pass
+
+    def __init__(self, pyfile):
+        Base.__init__(self, pyfile.m.core)
+
+        self.wantReconnect = False
+        #: enables simultaneous processing of multiple downloads
+        self.limitDL = 0
+        #: chunk limit
+        self.chunkLimit = 1
+        #: enables resume (will be ignored if server dont accept chunks)
+        self.resumeDownload = False
+
+        #: plugin is waiting
+        self.waiting = False
+
+        self.ocr = None  #captcha reader instance
+        #: account handler instance, see :py:class:`Account`
+        self.account = self.core.accountManager.getAccountForPlugin(self.__name__)
+
+        #: premium status
+        self.premium = False
+        #: username/login
+        self.user = None
+
+        if self.account and not self.account.isUsable(): self.account = None
+        if self.account:
+            self.user = self.account.loginname
+            #: Browser instance, see `network.Browser`
+            self.req = self.account.getAccountRequest()
+            # Default:  -1, True, True
+            self.chunkLimit, self.limitDL, self.resumeDownload = self.account.getDownloadSettings()
+            self.premium = self.account.isPremium()
+        else:
+            self.req = self.core.requestFactory.getRequest(self.__name__)
+
+        #: associated pyfile instance, see `PyFile`
+        self.pyfile = pyfile
+        self.thread = None # holds thread in future
+
+        #: location where the last call to download was saved
+        self.lastDownload = ""
+        #: re match of the last call to `checkDownload`
+        self.lastCheck = None
+        #: js engine, see `JsEngine`
+        self.js = self.core.js
+
+        self.retries = 0 # amount of retries already made
+        self.html = None # some plugins store html code here
+
+        self.init()
+
+    def getMultiDL(self):
+        return self.limitDL <= 0
+
+    def setMultiDL(self, val):
+        self.limitDL = 0 if val else 1
+
+    #: virtual attribute using self.limitDL on behind
+    multiDL = property(getMultiDL, setMultiDL)
+
+    def getChunkCount(self):
+        if self.chunkLimit <= 0:
+            return self.config["download"]["chunks"]
+        return min(self.config["download"]["chunks"], self.chunkLimit)
+
+    def getDownloadLimit(self):
+        if self.account:
+            limit = self.account.options.get("limitDL", 0)
+            if limit == "": limit = 0
+            if self.limitDL > 0: # a limit is already set, we use the minimum
+                return min(int(limit), self.limitDL)
+            else:
+                return int(limit)
+        else:
+            return self.limitDL
+
+
+    def __call__(self):
+        return self.__name__
+
+    def init(self):
+        """initialize the plugin (in addition to `__init__`)"""
+        pass
+
+    def setup(self):
+        """ setup for environment and other things, called before downloading (possibly more than one time)"""
+        pass
+
+    def preprocessing(self, thread):
+        """ handles important things to do before starting """
+        self.thread = thread
+
+        if self.account:
+            # will force a re-login or reload of account info if necessary
+            self.account.getAccountInfo()
+        else:
+            self.req.clearCookies()
+
+        self.setup()
+
+        self.pyfile.setStatus("starting")
+
+        return self.process(self.pyfile)
+
+    def process(self, pyfile):
+        """the 'main' method of every plugin, you **have to** overwrite it"""
+        raise NotImplementedError
+
+    def abort(self):
+        return self.pyfile.abort
+
+    def resetAccount(self):
+        """ don't use account and retry download """
+        self.account = None
+        self.req = self.core.requestFactory.getRequest(self.__name__)
+        self.retry()
+
+    def checksum(self, local_file=None):
+        """
+        return codes:
+        0  - checksum ok
+        1  - checksum wrong
+        5  - can't get checksum
+        10 - not implemented
+        20 - unknown error
+        """
+        #@TODO checksum check addon
+
+        return True, 10
+
+
+    def setWait(self, seconds, reconnect=False):
+        """Set a specific wait time later used with `wait`
+        
+        :param seconds: wait time in seconds
+        :param reconnect: True if a reconnect would avoid wait time
+        """
+        if reconnect:
+            self.wantReconnect = True
+        self.pyfile.waitUntil = time() + int(seconds)
+
+    def wait(self):
+        """ waits the time previously set """
+        self.waiting = True
+        self.pyfile.setStatus("waiting")
+
+        while self.pyfile.waitUntil > time():
+            self.thread.m.reconnecting.wait(2)
+
+            self.checkAbort()
+            if self.thread.m.reconnecting.isSet():
+                self.waiting = False
+                self.wantReconnect = False
+                raise Reconnect
+
+        self.waiting = False
+        self.pyfile.setStatus("starting")
+
+    def offline(self):
+        """ fail and indicate file is offline """
+        raise Fail("offline")
+
+    def tempOffline(self):
+        """ fail and indicates file ist temporary offline, the core may take consequences """
+        raise Fail("temp. offline")
+
+    def retry(self, max_tries=3, wait_time=1, reason=""):
+        """Retries and begin again from the beginning
+
+        :param max_tries: number of maximum retries
+        :param wait_time: time to wait in seconds
+        :param reason: reason for retrying, will be passed to fail if max_tries reached
+        """
+        if 0 < max_tries <= self.retries:
+            if not reason: reason = "Max retries reached"
+            raise Fail(reason)
+
+        self.wantReconnect = False
+        self.setWait(wait_time)
+        self.wait()
+
+        self.retries += 1
+        raise Retry(reason)
+
+
+    def download(self, url, get={}, post={}, ref=True, cookies=True, disposition=False):
+        """Downloads the content at url to download folder
+
+        :param url:
+        :param get:
+        :param post:
+        :param ref:
+        :param cookies:
+        :param disposition: if True and server provides content-disposition header\
+        the filename will be changed if needed
+        :return: The location where the file was saved
+        """
+        self.checkForSameFiles()
+        self.checkAbort()
+
+        self.pyfile.setStatus("downloading")
+
+        download_folder = self.config['general']['download_folder']
+
+        location = save_join(download_folder, self.pyfile.package().folder)
+
+        if not exists(location):
+            makedirs(location, int(self.core.config["permission"]["folder"], 8))
+
+            if self.core.config["permission"]["change_dl"] and os.name != "nt":
+                try:
+                    uid = getpwnam(self.config["permission"]["user"])[2]
+                    gid = getgrnam(self.config["permission"]["group"])[2]
+
+                    chown(location, uid, gid)
+                except Exception, e:
+                    self.log.warning(_("Setting User and Group failed: %s") % str(e))
+
+        # convert back to unicode
+        location = fs_decode(location)
+        name = save_filename(self.pyfile.name)
+
+        filename = join(location, name)
+
+        self.core.addonManager.dispatchEvent("download:start", self.pyfile, url, filename)
+
+        try:
+            newname = self.req.httpDownload(url, filename, get=get, post=post, ref=ref, cookies=cookies,
+                                            chunks=self.getChunkCount(), resume=self.resumeDownload,
+                                            disposition=disposition)
+        finally:
+            self.pyfile.size = self.req.size
+
+        if disposition and newname and newname != name: #triple check, just to be sure
+            self.log.info("%(name)s saved as %(newname)s" % {"name": name, "newname": newname})
+            self.pyfile.name = newname
+            filename = join(location, newname)
+
+        fs_filename = fs_encode(filename)
+
+        if self.core.config["permission"]["change_file"]:
+            chmod(fs_filename, int(self.core.config["permission"]["file"], 8))
+
+        if self.core.config["permission"]["change_dl"] and os.name != "nt":
+            try:
+                uid = getpwnam(self.config["permission"]["user"])[2]
+                gid = getgrnam(self.config["permission"]["group"])[2]
+
+                chown(fs_filename, uid, gid)
+            except Exception, e:
+                self.log.warning(_("Setting User and Group failed: %s") % str(e))
+
+        self.lastDownload = filename
+        return self.lastDownload
+
+    def checkDownload(self, rules, api_size=0, max_size=50000, delete=True, read_size=0):
+        """ checks the content of the last downloaded file, re match is saved to `lastCheck`
+        
+        :param rules: dict with names and rules to match (compiled regexp or strings)
+        :param api_size: expected file size
+        :param max_size: if the file is larger then it wont be checked
+        :param delete: delete if matched
+        :param read_size: amount of bytes to read from files larger then max_size
+        :return: dictionary key of the first rule that matched
+        """
+        lastDownload = fs_encode(self.lastDownload)
+        if not exists(lastDownload): return None
+
+        size = stat(lastDownload)
+        size = size.st_size
+
+        if api_size and api_size <= size: return None
+        elif size > max_size and not read_size: return None
+        self.log.debug("Download Check triggered")
+        f = open(lastDownload, "rb")
+        content = f.read(read_size if read_size else -1)
+        f.close()
+        #produces encoding errors, better log to other file in the future?
+        #self.log.debug("Content: %s" % content)
+        for name, rule in rules.iteritems():
+            if type(rule) in (str, unicode):
+                if rule in content:
+                    if delete:
+                        remove(lastDownload)
+                    return name
+            elif hasattr(rule, "search"):
+                m = rule.search(content)
+                if m:
+                    if delete:
+                        remove(lastDownload)
+                    self.lastCheck = m
+                    return name
+
+
+    def getPassword(self):
+        """ get the password the user provided in the package"""
+        password = self.pyfile.package().password
+        if not password: return ""
+        return password
+
+
+    def checkForSameFiles(self, starting=False):
+        """ checks if same file was/is downloaded within same package
+
+        :param starting: indicates that the current download is going to start
+        :raises SkipDownload:
+        """
+
+        pack = self.pyfile.package()
+
+        for pyfile in self.core.files.cachedFiles():
+            if pyfile != self.pyfile and pyfile.name == self.pyfile.name and pyfile.package().folder == pack.folder:
+                if pyfile.status in (0, 12): #finished or downloading
+                    raise SkipDownload(pyfile.pluginname)
+                elif pyfile.status in (
+                5, 7) and starting: #a download is waiting/starting and was apparently started before
+                    raise SkipDownload(pyfile.pluginname)
+
+        download_folder = self.config['general']['download_folder']
+        location = save_join(download_folder, pack.folder, self.pyfile.name)
+
+        if starting and self.core.config['download']['skip_existing'] and exists(location):
+            size = os.stat(location).st_size
+            if size >= self.pyfile.size:
+                raise SkipDownload("File exists.")
+
+        pyfile = self.core.db.findDuplicates(self.pyfile.id, self.pyfile.package().folder, self.pyfile.name)
+        if pyfile:
+            if exists(location):
+                raise SkipDownload(pyfile[0])
 
-def getInfo(self):
-        #result = [ .. (name, size, status, url) .. ]
-        return
+            self.log.debug("File %s not skipped, because it does not exists." % self.pyfile.name)
 
-class Hoster(Plugin):
-    __name__ = "Hoster"
-    __version__ = "0.1"
-    __pattern__ = None
-    __type__ = "hoster"
-    __description__ = """Base hoster plugin"""
-    __author_name__ = ("mkaay")
-    __author_mail__ = ("mkaay@mkaay.de")
+    def clean(self):
+        """ clean everything and remove references """
+        if hasattr(self, "pyfile"):
+            del self.pyfile
+        if hasattr(self, "req"):
+            self.req.close()
+            del self.req
+        if hasattr(self, "thread"):
+            del self.thread
+        if hasattr(self, "html"):
+            del self.html
diff --git a/module/plugins/MultiHoster.py b/module/plugins/MultiHoster.py
new file mode 100644
index 000000000..1936478b4
--- /dev/null
+++ b/module/plugins/MultiHoster.py
@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+
+from time import time
+
+from module.utils import remove_chars
+
+from Account import Account
+
+def normalize(domain):
+   """ Normalize domain/plugin name, so they are comparable """
+   return remove_chars(domain.strip().lower(), "-.")
+
+#noinspection PyUnresolvedReferences
+class MultiHoster(Account):
+    """
+    Base class for MultiHoster services.
+    This is also an Account instance so you should see :class:`Account` and overwrite necessary methods.
+    Multihoster becomes only active when an Account was entered and the MultiHoster addon was activated.
+    You need to overwrite `loadHosterList` and a corresponding :class:`Hoster` plugin with the same name should
+    be available to make your service working.
+    """
+
+    #: List of hoster names that will be replaced so pyLoad will recognize them: (orig_name, pyload_name)
+    replacements = [("freakshare.net", "freakshare.com")]
+
+    #: Load new hoster list every x seconds
+    hoster_timeout = 300
+
+    def __init__(self, *args, **kwargs):
+
+        # Hoster list
+        self.hoster = []
+        # Timestamp
+        self.ts = 0
+
+        Account.__init__(self, *args, **kwargs)
+
+    def loadHosterList(self, req):
+        """Load list of supported hoster
+
+        :return: List of domain names
+        """
+        raise NotImplementedError
+
+
+    def isHosterUsuable(self, domain):
+        """ Determine before downloading if hoster should be used.
+
+        :param domain: domain name
+        :return: True to let the MultiHoster download, False to fallback to default plugin
+        """
+        return True
+
+    def getHosterList(self, force=False):
+        if self.ts + self.hoster_timeout < time() or force:
+            req = self.getAccountRequest()
+            try:
+                self.hoster = self.loadHosterList(req)
+            except Exception, e:
+                self.logError(e)
+                return []
+            finally:
+                req.close()
+
+            for rep in self.replacements:
+                if rep[0] in self.hoster:
+                    self.hoster.remove(rep[0])
+                    if rep[1] not in self.hoster:
+                        self.hoster.append(rep[1])
+
+            self.ts = time()
+
+        return self.hoster
\ No newline at end of file
diff --git a/module/plugins/Plugin.py b/module/plugins/Plugin.py
deleted file mode 100644
index 15bf3971f..000000000
--- a/module/plugins/Plugin.py
+++ /dev/null
@@ -1,617 +0,0 @@
-# -*- coding: utf-8 -*-
-
-"""
-    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/>.
-
-    @author: RaNaN, spoob, mkaay
-"""
-
-from time import time, sleep
-from random import randint
-
-import os
-from os import remove, makedirs, chmod, stat
-from os.path import exists, join
-
-if os.name != "nt":
-    from os import chown
-    from pwd import getpwnam
-    from grp import getgrnam
-
-from itertools import islice
-
-from module.utils import save_join, save_path, fs_encode, fs_decode
-
-def chunks(iterable, size):
-    it = iter(iterable)
-    item = list(islice(it, size))
-    while item:
-        yield item
-        item = list(islice(it, size))
-
-
-class Abort(Exception):
-    """ raised when aborted """
-
-
-class Fail(Exception):
-    """ raised when failed """
-
-
-class Reconnect(Exception):
-    """ raised when reconnected """
-
-
-class Retry(Exception):
-    """ raised when start again from beginning """
-
-
-class SkipDownload(Exception):
-    """ raised when download should be skipped """
-
-
-class Base(object):
-    """
-    A Base class with log/config/db methods *all* plugin types can use
-    """
-
-    def __init__(self, core):
-        #: Core instance
-        self.core = core
-        #: logging instance
-        self.log = core.log
-        #: core config
-        self.config = core.config
-
-    #log functions
-    def logInfo(self, *args):
-        self.log.info("%s: %s" % (self.__name__, " | ".join([a if isinstance(a, basestring) else str(a) for a in args])))
-
-    def logWarning(self, *args):
-        self.log.warning("%s: %s" % (self.__name__, " | ".join([a if isinstance(a, basestring) else str(a) for a in args])))
-
-    def logError(self, *args):
-        self.log.error("%s: %s" % (self.__name__, " | ".join([a if isinstance(a, basestring) else str(a) for a in args])))
-
-    def logDebug(self, *args):
-        self.log.debug("%s: %s" % (self.__name__, " | ".join([a if isinstance(a, basestring) else str(a) for a in args])))
-
-
-    def setConf(self, option, value):
-        """ see `setConfig` """
-        self.core.config.setPlugin(self.__name__, option, value)
-
-    def setConfig(self, option, value):
-        """ Set config value for current plugin
-
-        :param option:
-        :param value:
-        :return:
-        """
-        self.setConf(option, value)
-
-    def getConf(self, option):
-        """ see `getConfig` """
-        return self.core.config.getPlugin(self.__name__, option)
-
-    def getConfig(self, option):
-        """ Returns config value for current plugin
-
-        :param option:
-        :return:
-        """
-        return self.getConf(option)
-
-    def setStorage(self, key, value):
-        """ Saves a value persistently to the database """
-        self.core.db.setStorage(self.__name__, key, value)
-
-    def store(self, key, value):
-        """ same as `setStorage` """
-        self.core.db.setStorage(self.__name__, key, value)
-
-    def getStorage(self, key=None, default=None):
-        """ Retrieves saved value or dict of all saved entries if key is None """
-        if key is not None:
-            return self.core.db.getStorage(self.__name__, key) or default
-        return self.core.db.getStorage(self.__name__, key)
-
-    def retrieve(self, *args, **kwargs):
-        """ same as `getStorage` """
-        return self.getStorage(*args, **kwargs)
-
-    def delStorage(self, key):
-        """ Delete entry in db """
-        self.core.db.delStorage(self.__name__, key)
-
-
-class Plugin(Base):
-    """
-    Base plugin for hoster/crypter.
-    Overwrite `process` / `decrypt` in your subclassed plugin.
-    """
-    __name__ = "Plugin"
-    __version__ = "0.4"
-    __pattern__ = None
-    __type__ = "hoster"
-    __config__ = [("name", "type", "desc", "default")]
-    __description__ = """Base Plugin"""
-    __author_name__ = ("RaNaN", "spoob", "mkaay")
-    __author_mail__ = ("RaNaN@pyload.org", "spoob@pyload.org", "mkaay@mkaay.de")
-
-    def __init__(self, pyfile):
-        Base.__init__(self, pyfile.m.core)
-
-        self.wantReconnect = False
-        #: enables simultaneous processing of multiple downloads
-        self.multiDL = True
-        self.limitDL = 0
-        #: chunk limit
-        self.chunkLimit = 1
-        self.resumeDownload = False
-
-        #: time() + wait in seconds
-        self.waitUntil = 0
-        self.waiting = False
-
-        self.ocr = None  #captcha reader instance
-        #: account handler instance, see :py:class:`Account`
-        self.account = pyfile.m.core.accountManager.getAccountPlugin(self.__name__)
-
-        #: premium status
-        self.premium = False
-        #: username/login
-        self.user = None
-
-        if self.account and not self.account.canUse(): self.account = None
-        if self.account:
-            self.user, data = self.account.selectAccount()
-            #: Browser instance, see `network.Browser`
-            self.req = self.account.getAccountRequest(self.user)
-            self.chunkLimit = -1 # chunk limit, -1 for unlimited
-            #: enables resume (will be ignored if server dont accept chunks)
-            self.resumeDownload = True
-            self.multiDL = True  #every hoster with account should provide multiple downloads
-            #: premium status
-            self.premium = self.account.isPremium(self.user)
-        else:
-            self.req = pyfile.m.core.requestFactory.getRequest(self.__name__)
-
-        #: associated pyfile instance, see `PyFile`
-        self.pyfile = pyfile
-        self.thread = None # holds thread in future
-
-        #: location where the last call to download was saved
-        self.lastDownload = ""
-        #: re match of the last call to `checkDownload`
-        self.lastCheck = None
-        #: js engine, see `JsEngine`
-        self.js = self.core.js
-        self.cTask = None #captcha task
-
-        self.retries = 0 # amount of retries already made
-        self.html = None # some plugins store html code here
-
-        self.init()
-
-    def getChunkCount(self):
-        if self.chunkLimit <= 0:
-            return self.config["download"]["chunks"]
-        return min(self.config["download"]["chunks"], self.chunkLimit)
-
-    def __call__(self):
-        return self.__name__
-
-    def init(self):
-        """initialize the plugin (in addition to `__init__`)"""
-        pass
-
-    def setup(self):
-        """ setup for enviroment and other things, called before downloading (possibly more than one time)"""
-        pass
-
-    def preprocessing(self, thread):
-        """ handles important things to do before starting """
-        self.thread = thread
-
-        if self.account:
-            self.account.checkLogin(self.user)
-        else:
-            self.req.clearCookies()
-
-        self.setup()
-
-        self.pyfile.setStatus("starting")
-
-        return self.process(self.pyfile)
-
-
-    def process(self, pyfile):
-        """the 'main' method of every plugin, you **have to** overwrite it"""
-        raise NotImplementedError
-
-    def resetAccount(self):
-        """ dont use account and retry download """
-        self.account = None
-        self.req = self.core.requestFactory.getRequest(self.__name__)
-        self.retry()
-
-    def checksum(self, local_file=None):
-        """
-        return codes:
-        0  - checksum ok
-        1  - checksum wrong
-        5  - can't get checksum
-        10 - not implemented
-        20 - unknown error
-        """
-        #@TODO checksum check hook
-
-        return True, 10
-
-
-    def setWait(self, seconds, reconnect=False):
-        """Set a specific wait time later used with `wait`
-        
-        :param seconds: wait time in seconds
-        :param reconnect: True if a reconnect would avoid wait time
-        """
-        if reconnect:
-            self.wantReconnect = True
-        self.pyfile.waitUntil = time() + int(seconds)
-
-    def wait(self):
-        """ waits the time previously set """
-        self.waiting = True
-        self.pyfile.setStatus("waiting")
-
-        while self.pyfile.waitUntil > time():
-            self.thread.m.reconnecting.wait(2)
-
-            if self.pyfile.abort: raise Abort
-            if self.thread.m.reconnecting.isSet():
-                self.waiting = False
-                self.wantReconnect = False
-                raise Reconnect
-
-        self.waiting = False
-        self.pyfile.setStatus("starting")
-
-    def fail(self, reason):
-        """ fail and give reason """
-        raise Fail(reason)
-
-    def offline(self):
-        """ fail and indicate file is offline """
-        raise Fail("offline")
-
-    def tempOffline(self):
-        """ fail and indicates file ist temporary offline, the core may take consequences """
-        raise Fail("temp. offline")
-
-    def retry(self, max_tries=3, wait_time=1, reason=""):
-        """Retries and begin again from the beginning
-
-        :param max_tries: number of maximum retries
-        :param wait_time: time to wait in seconds
-        :param reason: reason for retrying, will be passed to fail if max_tries reached
-        """
-        if 0 < max_tries <= self.retries:
-            if not reason: reason = "Max retries reached"
-            raise Fail(reason)
-
-        self.wantReconnect = False
-        self.setWait(wait_time)
-        self.wait()
-
-        self.retries += 1
-        raise Retry(reason)
-
-    def invalidCaptcha(self):
-        if self.cTask:
-            self.cTask.invalid()
-
-    def correctCaptcha(self):
-        if self.cTask:
-            self.cTask.correct()
-
-    def decryptCaptcha(self, url, get={}, post={}, cookies=False, forceUser=False, imgtype='jpg',
-                       result_type='textual'):
-        """ Loads a captcha and decrypts it with ocr, plugin, user input
-
-        :param url: url of captcha image
-        :param get: get part for request
-        :param post: post part for request
-        :param cookies: True if cookies should be enabled
-        :param forceUser: if True, ocr is not used
-        :param imgtype: Type of the Image
-        :param result_type: 'textual' if text is written on the captcha\
-        or 'positional' for captcha where the user have to click\
-        on a specific region on the captcha
-        
-        :return: result of decrypting
-        """
-
-        img = self.load(url, get=get, post=post, cookies=cookies)
-
-        id = ("%.2f" % time())[-6:].replace(".", "")
-        temp_file = open(join("tmp", "tmpCaptcha_%s_%s.%s" % (self.__name__, id, imgtype)), "wb")
-        temp_file.write(img)
-        temp_file.close()
-
-        has_plugin = self.__name__ in self.core.pluginManager.captchaPlugins
-
-        if self.core.captcha:
-            Ocr = self.core.pluginManager.loadClass("captcha", self.__name__)
-        else:
-            Ocr = None
-
-        if Ocr and not forceUser:
-            sleep(randint(3000, 5000) / 1000.0)
-            if self.pyfile.abort: raise Abort
-
-            ocr = Ocr()
-            result = ocr.get_captcha(temp_file.name)
-        else:
-            captchaManager = self.core.captchaManager
-            task = captchaManager.newTask(img, imgtype, temp_file.name, result_type)
-            self.cTask = task
-            captchaManager.handleCaptcha(task)
-
-            while task.isWaiting():
-                if self.pyfile.abort:
-                    captchaManager.removeTask(task)
-                    raise Abort
-                sleep(1)
-
-            captchaManager.removeTask(task)
-
-            if task.error and has_plugin: #ignore default error message since the user could use OCR
-                self.fail(_("Pil and tesseract not installed and no Client connected for captcha decrypting"))
-            elif task.error:
-                self.fail(task.error)
-            elif not task.result:
-                self.fail(_("No captcha result obtained in appropiate time by any of the plugins."))
-
-            result = task.result
-            self.log.debug("Received captcha result: %s" % str(result))
-
-        if not self.core.debug:
-            try:
-                remove(temp_file.name)
-            except:
-                pass
-
-        return result
-
-
-    def load(self, url, get={}, post={}, ref=True, cookies=True, just_header=False, decode=False):
-        """Load content at url and returns it
-
-        :param url:
-        :param get:
-        :param post:
-        :param ref:
-        :param cookies:
-        :param just_header: if True only the header will be retrieved and returned as dict
-        :param decode: Wether to decode the output according to http header, should be True in most cases
-        :return: Loaded content
-        """
-        if self.pyfile.abort: raise Abort
-        #utf8 vs decode -> please use decode attribute in all future plugins
-        if type(url) == unicode: url = str(url)
-
-        res = self.req.load(url, get, post, ref, cookies, just_header, decode=decode)
-
-        if self.core.debug:
-            from inspect import currentframe
-
-            frame = currentframe()
-            if not exists(join("tmp", self.__name__)):
-                makedirs(join("tmp", self.__name__))
-
-            f = open(
-                join("tmp", self.__name__, "%s_line%s.dump.html" % (frame.f_back.f_code.co_name, frame.f_back.f_lineno))
-                , "wb")
-            del frame # delete the frame or it wont be cleaned
-
-            try:
-                tmp = res.encode("utf8")
-            except:
-                tmp = res
-
-            f.write(tmp)
-            f.close()
-
-        if just_header:
-            #parse header
-            header = {"code": self.req.code}
-            for line in res.splitlines():
-                line = line.strip()
-                if not line or ":" not in line: continue
-
-                key, none, value = line.partition(":")
-                key = key.lower().strip()
-                value = value.strip()
-
-                if key in header:
-                    if type(header[key]) == list:
-                        header[key].append(value)
-                    else:
-                        header[key] = [header[key], value]
-                else:
-                    header[key] = value
-            res = header
-
-        return res
-
-    def download(self, url, get={}, post={}, ref=True, cookies=True, disposition=False):
-        """Downloads the content at url to download folder
-
-        :param url:
-        :param get:
-        :param post:
-        :param ref:
-        :param cookies:
-        :param disposition: if True and server provides content-disposition header\
-        the filename will be changed if needed
-        :return: The location where the file was saved
-        """
-
-        self.checkForSameFiles()
-
-        self.pyfile.setStatus("downloading")
-
-        download_folder = self.config['general']['download_folder']
-
-        location = save_join(download_folder, self.pyfile.package().folder)
-
-        if not exists(location):
-            makedirs(location, int(self.core.config["permission"]["folder"], 8))
-
-            if self.core.config["permission"]["change_dl"] and os.name != "nt":
-                try:
-                    uid = getpwnam(self.config["permission"]["user"])[2]
-                    gid = getgrnam(self.config["permission"]["group"])[2]
-
-                    chown(location, uid, gid)
-                except Exception, e:
-                    self.log.warning(_("Setting User and Group failed: %s") % str(e))
-
-        # convert back to unicode
-        location = fs_decode(location)
-        name = save_path(self.pyfile.name)
-
-        filename = join(location, name)
-
-        self.core.hookManager.dispatchEvent("downloadStarts", self.pyfile, url, filename)
-
-        try:
-            newname = self.req.httpDownload(url, filename, get=get, post=post, ref=ref, cookies=cookies,
-                                            chunks=self.getChunkCount(), resume=self.resumeDownload,
-                                            progressNotify=self.pyfile.setProgress, disposition=disposition)
-        finally:
-            self.pyfile.size = self.req.size
-
-        if disposition and newname and newname != name: #triple check, just to be sure
-            self.log.info("%(name)s saved as %(newname)s" % {"name": name, "newname": newname})
-            self.pyfile.name = newname
-            filename = join(location, newname)
-
-        fs_filename = fs_encode(filename)
-
-        if self.core.config["permission"]["change_file"]:
-            chmod(fs_filename, int(self.core.config["permission"]["file"], 8))
-
-        if self.core.config["permission"]["change_dl"] and os.name != "nt":
-            try:
-                uid = getpwnam(self.config["permission"]["user"])[2]
-                gid = getgrnam(self.config["permission"]["group"])[2]
-
-                chown(fs_filename, uid, gid)
-            except Exception, e:
-                self.log.warning(_("Setting User and Group failed: %s") % str(e))
-
-        self.lastDownload = filename
-        return self.lastDownload
-
-    def checkDownload(self, rules, api_size=0, max_size=50000, delete=True, read_size=0):
-        """ checks the content of the last downloaded file, re match is saved to `lastCheck`
-        
-        :param rules: dict with names and rules to match (compiled regexp or strings)
-        :param api_size: expected file size
-        :param max_size: if the file is larger then it wont be checked
-        :param delete: delete if matched
-        :param read_size: amount of bytes to read from files larger then max_size
-        :return: dictionary key of the first rule that matched
-        """
-        lastDownload = fs_encode(self.lastDownload)
-        if not exists(lastDownload): return None
-
-        size = stat(lastDownload)
-        size = size.st_size
-
-        if api_size and api_size <= size: return None
-        elif size > max_size and not read_size: return None
-        self.log.debug("Download Check triggered")
-        f = open(lastDownload, "rb")
-        content = f.read(read_size if read_size else -1)
-        f.close()
-        #produces encoding errors, better log to other file in the future?
-        #self.log.debug("Content: %s" % content)
-        for name, rule in rules.iteritems():
-            if type(rule) in (str, unicode):
-                if rule in content:
-                    if delete:
-                        remove(lastDownload)
-                    return name
-            elif hasattr(rule, "search"):
-                m = rule.search(content)
-                if m:
-                    if delete:
-                        remove(lastDownload)
-                    self.lastCheck = m
-                    return name
-
-
-    def getPassword(self):
-        """ get the password the user provided in the package"""
-        password = self.pyfile.package().password
-        if not password: return ""
-        return password
-
-
-    def checkForSameFiles(self, starting=False):
-        """ checks if same file was/is downloaded within same package
-
-        :param starting: indicates that the current download is going to start
-        :raises SkipDownload:
-        """
-
-        pack = self.pyfile.package()
-
-        for pyfile in self.core.files.cache.values():
-            if pyfile != self.pyfile and pyfile.name == self.pyfile.name and pyfile.package().folder == pack.folder:
-                if pyfile.status in (0, 12): #finished or downloading
-                    raise SkipDownload(pyfile.pluginname)
-                elif pyfile.status in (
-                5, 7) and starting: #a download is waiting/starting and was appenrently started before
-                    raise SkipDownload(pyfile.pluginname)
-
-        download_folder = self.config['general']['download_folder']
-        location = save_join(download_folder, pack.folder, self.pyfile.name)
-
-        if starting and self.core.config['download']['skip_existing'] and exists(location):
-            size = os.stat(location).st_size
-            if size >= self.pyfile.size:
-                raise SkipDownload("File exists.")
-
-        pyfile = self.core.db.findDuplicates(self.pyfile.id, self.pyfile.package().folder, self.pyfile.name)
-        if pyfile:
-            if exists(location):
-                raise SkipDownload(pyfile[0])
-
-            self.log.debug("File %s not skipped, because it does not exists." % self.pyfile.name)
-
-    def clean(self):
-        """ clean everything and remove references """
-        if hasattr(self, "pyfile"):
-            del self.pyfile
-        if hasattr(self, "req"):
-            self.req.close()
-            del self.req
-        if hasattr(self, "thread"):
-            del self.thread
-        if hasattr(self, "html"):
-            del self.html
diff --git a/module/plugins/PluginManager.py b/module/plugins/PluginManager.py
deleted file mode 100644
index f3f5f47bc..000000000
--- a/module/plugins/PluginManager.py
+++ /dev/null
@@ -1,380 +0,0 @@
-# -*- coding: utf-8 -*-
-
-"""
-    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/>.
-    
-    @author: mkaay, RaNaN
-"""
-
-import re
-import sys
-
-from os import listdir, makedirs
-from os.path import isfile, join, exists, abspath
-from sys import version_info
-from itertools import chain
-from traceback import print_exc
-
-from module.lib.SafeEval import const_eval as literal_eval
-from module.ConfigParser import IGNORE
-
-class PluginManager:
-    ROOT = "module.plugins."
-    USERROOT = "userplugins."
-    TYPES = ("crypter", "container", "hoster", "captcha", "accounts", "hooks", "internal")
-
-    PATTERN = re.compile(r'__pattern__.*=.*r("|\')([^"\']+)')
-    VERSION = re.compile(r'__version__.*=.*("|\')([0-9.]+)')
-    CONFIG = re.compile(r'__config__.*=.*\[([^\]]+)', re.MULTILINE)
-    DESC = re.compile(r'__description__.?=.?("|"""|\')([^"\']+)')
-
-
-    def __init__(self, core):
-        self.core = core
-
-        #self.config = self.core.config
-        self.log = core.log
-
-        self.plugins = {}
-        self.createIndex()
-
-        #register for import hook
-        sys.meta_path.append(self)
-
-
-    def createIndex(self):
-        """create information for all plugins available"""
-
-        sys.path.append(abspath(""))
-
-        if not exists("userplugins"):
-            makedirs("userplugins")
-        if not exists(join("userplugins", "__init__.py")):
-            f = open(join("userplugins", "__init__.py"), "wb")
-            f.close()
-
-        self.plugins["crypter"] = self.crypterPlugins = self.parse("crypter", pattern=True)
-        self.plugins["container"] = self.containerPlugins = self.parse("container", pattern=True)
-        self.plugins["hoster"] = self.hosterPlugins = self.parse("hoster", pattern=True)
-
-        self.plugins["captcha"] = self.captchaPlugins = self.parse("captcha")
-        self.plugins["accounts"] = self.accountPlugins = self.parse("accounts")
-        self.plugins["hooks"] = self.hookPlugins = self.parse("hooks")
-        self.plugins["internal"] = self.internalPlugins = self.parse("internal")
-
-        self.log.debug("created index of plugins")
-
-    def parse(self, folder, pattern=False, home={}):
-        """
-        returns dict with information 
-        home contains parsed plugins from module.
-        
-        {
-        name : {path, version, config, (pattern, re), (plugin, class)}
-        }
-        
-        """
-        plugins = {}
-        if home:
-            pfolder = join("userplugins", folder)
-            if not exists(pfolder):
-                makedirs(pfolder)
-            if not exists(join(pfolder, "__init__.py")):
-                f = open(join(pfolder, "__init__.py"), "wb")
-                f.close()
-
-        else:
-            pfolder = join(pypath, "module", "plugins", folder)
-
-        for f in listdir(pfolder):
-            if (isfile(join(pfolder, f)) and f.endswith(".py") or f.endswith("_25.pyc") or f.endswith(
-                "_26.pyc") or f.endswith("_27.pyc")) and not f.startswith("_"):
-                data = open(join(pfolder, f))
-                content = data.read()
-                data.close()
-
-                if f.endswith("_25.pyc") and version_info[0:2] != (2, 5):
-                    continue
-                elif f.endswith("_26.pyc") and version_info[0:2] != (2, 6):
-                    continue
-                elif f.endswith("_27.pyc") and version_info[0:2] != (2, 7):
-                    continue
-
-                name = f[:-3]
-                if name[-1] == ".": name = name[:-4]
-
-                version = self.VERSION.findall(content)
-                if version:
-                    version = float(version[0][1])
-                else:
-                    version = 0
-
-                # home contains plugins from pyload root
-                if home and name in home:
-                    if home[name]["v"] >= version:
-                        continue
-
-                if name in IGNORE or (folder, name) in IGNORE:
-                     continue
-
-                plugins[name] = {}
-                plugins[name]["v"] = version
-
-                module = f.replace(".pyc", "").replace(".py", "")
-
-                # the plugin is loaded from user directory
-                plugins[name]["user"] = True if home else False
-                plugins[name]["name"] = module
-
-                if pattern:
-                    pattern = self.PATTERN.findall(content)
-
-                    if pattern:
-                        pattern = pattern[0][1]
-                    else:
-                        pattern = "^unmachtable$"
-
-                    plugins[name]["pattern"] = pattern
-
-                    try:
-                        plugins[name]["re"] = re.compile(pattern)
-                    except:
-                        self.log.error(_("%s has a invalid pattern.") % name)
-
-
-                # internals have no config
-                if folder == "internal":
-                    self.core.config.deleteConfig(name)
-                    continue
-
-                config = self.CONFIG.findall(content)
-                if config:
-                    config = literal_eval(config[0].strip().replace("\n", "").replace("\r", ""))
-                    desc = self.DESC.findall(content)
-                    desc = desc[0][1] if desc else ""
-
-                    if type(config[0]) == tuple:
-                        config = [list(x) for x in config]
-                    else:
-                        config = [list(config)]
-
-                    if folder == "hooks":
-                        append = True
-                        for item in config:
-                            if item[0] == "activated": append = False
-
-                        # activated flag missing
-                        if append: config.append(["activated", "bool", "Activated", False])
-
-                    try:
-                        self.core.config.addPluginConfig(name, config, desc)
-                    except:
-                        self.log.error("Invalid config in %s: %s" % (name, config))
-
-                elif folder == "hooks": #force config creation
-                    desc = self.DESC.findall(content)
-                    desc = desc[0][1] if desc else ""
-                    config = (["activated", "bool", "Activated", False],)
-
-                    try:
-                        self.core.config.addPluginConfig(name, config, desc)
-                    except:
-                        self.log.error("Invalid config in %s: %s" % (name, config))
-
-        if not home:
-            temp = self.parse(folder, pattern, plugins)
-            plugins.update(temp)
-
-        return plugins
-
-
-    def parseUrls(self, urls):
-        """parse plugins for given list of urls"""
-
-        last = None
-        res = [] # tupels of (url, plugin)
-
-        for url in urls:
-            if type(url) not in (str, unicode, buffer): continue
-            found = False
-
-            if last and last[1]["re"].match(url):
-                res.append((url, last[0]))
-                continue
-
-            for name, value in chain(self.crypterPlugins.iteritems(), self.hosterPlugins.iteritems(),
-                self.containerPlugins.iteritems()):
-                if value["re"].match(url):
-                    res.append((url, name))
-                    last = (name, value)
-                    found = True
-                    break
-
-            if not found:
-                res.append((url, "BasePlugin"))
-
-        return res
-
-    def findPlugin(self, name, pluginlist=("hoster", "crypter", "container")):
-        for ptype in pluginlist:
-            if name in self.plugins[ptype]:
-                return self.plugins[ptype][name], ptype
-        return None, None
-
-    def getPlugin(self, name, original=False):
-        """return plugin module from hoster|decrypter|container"""
-        plugin, type = self.findPlugin(name)
-
-        if not plugin:
-            self.log.warning("Plugin %s not found." % name)
-            plugin = self.hosterPlugins["BasePlugin"]
-
-        if "new_module" in plugin and not original:
-            return plugin["new_module"]
-
-        return self.loadModule(type, name)
-
-    def getPluginName(self, name):
-        """ used to obtain new name if other plugin was injected"""
-        plugin, type = self.findPlugin(name)
-
-        if "new_name" in plugin:
-            return plugin["new_name"]
-
-        return name
-
-    def loadModule(self, type, name):
-        """ Returns loaded module for plugin
-
-        :param type: plugin type, subfolder of module.plugins
-        :param name:
-        """
-        plugins = self.plugins[type]
-        if name in plugins:
-            if "module" in plugins[name]: return plugins[name]["module"]
-            try:
-                module = __import__(self.ROOT + "%s.%s" % (type, plugins[name]["name"]), globals(), locals(),
-                    plugins[name]["name"])
-                plugins[name]["module"] = module  #cache import, maybe unneeded
-                return module
-            except Exception, e:
-                self.log.error(_("Error importing %(name)s: %(msg)s") % {"name": name, "msg": str(e)})
-                if self.core.debug:
-                    print_exc()
-
-    def loadClass(self, type, name):
-        """Returns the class of a plugin with the same name"""
-        module = self.loadModule(type, name)
-        if module: return getattr(module, name)
-
-    def getAccountPlugins(self):
-        """return list of account plugin names"""
-        return self.accountPlugins.keys()
-
-    def find_module(self, fullname, path=None):
-        #redirecting imports if necesarry
-        if fullname.startswith(self.ROOT) or fullname.startswith(self.USERROOT): #seperate pyload plugins
-            if fullname.startswith(self.USERROOT): user = 1
-            else: user = 0 #used as bool and int
-
-            split = fullname.split(".")
-            if len(split) != 4 - user: return
-            type, name = split[2 - user:4 - user]
-
-            if type in self.plugins and name in self.plugins[type]:
-                #userplugin is a newer version
-                if not user and self.plugins[type][name]["user"]:
-                    return self
-                #imported from userdir, but pyloads is newer
-                if user and not self.plugins[type][name]["user"]:
-                    return self
-
-
-    def load_module(self, name, replace=True):
-        if name not in sys.modules:  #could be already in modules
-            if replace:
-                if self.ROOT in name:
-                    newname = name.replace(self.ROOT, self.USERROOT)
-                else:
-                    newname = name.replace(self.USERROOT, self.ROOT)
-            else: newname = name
-
-            base, plugin = newname.rsplit(".", 1)
-
-            self.log.debug("Redirected import %s -> %s" % (name, newname))
-
-            module = __import__(newname, globals(), locals(), [plugin])
-            #inject under new an old name
-            sys.modules[name] = module
-            sys.modules[newname] = module
-
-        return sys.modules[name]
-
-
-    def reloadPlugins(self, type_plugins):
-        """ reloads and reindexes plugins """
-        if not type_plugins: return False
-
-        self.log.debug("Request reload of plugins: %s" % type_plugins)
-
-        as_dict = {}
-        for t,n in type_plugins:
-            if t in as_dict:
-                as_dict[t].append(n)
-            else:
-                as_dict[t] = [n]
-
-        # we do not reload hooks or internals, would cause to much side effects
-        if "hooks" in as_dict or "internal" in as_dict:
-            return False
-
-        for type in as_dict.iterkeys():
-            for plugin in as_dict[type]:
-                if plugin in self.plugins[type]:
-                    if "module" in self.plugins[type][plugin]:
-                        self.log.debug("Reloading %s" % plugin)
-                        reload(self.plugins[type][plugin]["module"])
-
-        #index creation
-        self.plugins["crypter"] = self.crypterPlugins = self.parse("crypter", pattern=True)
-        self.plugins["container"] = self.containerPlugins = self.parse("container", pattern=True)
-        self.plugins["hoster"] = self.hosterPlugins = self.parse("hoster", pattern=True)
-        self.plugins["captcha"] = self.captchaPlugins = self.parse("captcha")
-        self.plugins["accounts"] = self.accountPlugins = self.parse("accounts")
-
-        if "accounts" in as_dict: #accounts needs to be reloaded
-            self.core.accountManager.initPlugins()
-            self.core.scheduler.addJob(0, self.core.accountManager.getAccountInfos)
-
-        return True
-
-
-
-if __name__ == "__main__":
-    _ = lambda x: x
-    pypath = "/home/christian/Projekte/pyload-0.4/module/plugins"
-
-    from time import time
-
-    p = PluginManager(None)
-
-    a = time()
-
-    test = ["http://www.youtube.com/watch?v=%s" % x for x in range(0, 100)]
-    print p.parseUrls(test)
-
-    b = time()
-
-    print b - a, "s"
-    
diff --git a/module/plugins/accounts/Premium4Me.py b/module/plugins/accounts/Premium4Me.py
index de4fdc219..6a52cb61a 100644
--- a/module/plugins/accounts/Premium4Me.py
+++ b/module/plugins/accounts/Premium4Me.py
@@ -1,23 +1,27 @@
-from module.plugins.Account import Account

+# -*- coding: utf-8 -*-

+from module.plugins.MultiHoster import MultiHoster

 

-class Premium4Me(Account):

+class Premium4Me(MultiHoster):

     __name__ = "Premium4Me"

-    __version__ = "0.02"

+    __version__ = "0.10"

     __type__ = "account"

     __description__ = """Premium4.me account plugin"""

     __author_name__ = ("RaNaN", "zoidberg")

     __author_mail__ = ("RaNaN@pyload.org", "zoidberg@mujmail.cz")

 

-    def loadAccountInfo(self, user, req):

+    def loadAccountInfo(self, req):

         traffic = req.load("http://premium4.me/api/traffic.php?authcode=%s" % self.authcode)

 

-        account_info = {"trafficleft": int(traffic) / 1024,

-                        "validuntil": -1}

+        account_info = {"trafficleft": int(traffic) / 1024, "validuntil": -1}

 

         return account_info

 

-    def login(self, user, data, req):

-        self.authcode = req.load("http://premium4.me/api/getauthcode.php?username=%s&password=%s" % (user, data["password"])).strip()

-        

+    def login(self, req):

+        self.authcode = req.load("http://premium4.me/api/getauthcode.php?username=%s&password=%s" % (self.loginname, self.password)).strip()

+

         if "wrong username" in self.authcode:

-            self.wrongPassword()
\ No newline at end of file
+            self.wrongPassword()

+        

+    def loadHosterList(self, req):

+        page = req.load("http://premium4.me/api/hosters.php?authcode=%s" % self.authcode)

+        return [x.strip() for x in page.replace("\"", "").split(";")]
\ No newline at end of file
diff --git a/module/plugins/accounts/RealdebridCom.py b/module/plugins/accounts/RealdebridCom.py
index adbd090db..9460fc815 100644
--- a/module/plugins/accounts/RealdebridCom.py
+++ b/module/plugins/accounts/RealdebridCom.py
@@ -1,25 +1,35 @@
-from module.plugins.Account import Account

-import xml.dom.minidom as dom

-

-class RealdebridCom(Account):

-    __name__ = "RealdebridCom"

-    __version__ = "0.41"

-    __type__ = "account"

-    __description__ = """Real-Debrid.com account plugin"""

-    __author_name__ = ("Devirex, Hazzard")

-    __author_mail__ = ("naibaf_11@yahoo.de")

-

-    def loadAccountInfo(self, user, req):

-        page = req.load("http://real-debrid.com/api/account.php")

-        xml = dom.parseString(page)

-        account_info = {"validuntil": int(xml.getElementsByTagName("expiration")[0].childNodes[0].nodeValue),

-                        "trafficleft": -1}

-

-        return account_info

-

-    def login(self, user, data, req):

-        page = req.load("https://real-debrid.com/ajax/login.php", get = {"user": user, "pass": data["password"]})

-        #page = req.load("https://real-debrid.com/login.html", post={"user": user, "pass": data["password"]}, cookies=True)

-

-        if "Your login informations are incorrect" in page:

-            self.wrongPassword()

+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from module.plugins.MultiHoster import MultiHoster
+import xml.dom.minidom as dom
+
+class RealdebridCom(MultiHoster):
+    __name__ = "RealdebridCom"
+    __version__ = "0.5"
+    __type__ = "account"
+    __description__ = """Real-Debrid.com account plugin"""
+    __author_name__ = ("Devirex, Hazzard")
+    __author_mail__ = ("naibaf_11@yahoo.de")
+
+    def loadAccountInfo(self, req):
+        page = req.load("http://real-debrid.com/api/account.php")
+        xml = dom.parseString(page)
+        account_info = {"validuntil": int(xml.getElementsByTagName("expiration")[0].childNodes[0].nodeValue),
+                        "trafficleft": -1}
+
+        return account_info
+
+    def login(self, req):
+        page = req.load("https://real-debrid.com/ajax/login.php?user=%s&pass=%s" % (self.loginname, self.password))
+        #page = req.load("https://real-debrid.com/login.html", post={"user": user, "pass": data["password"]}, cookies=True)
+
+        if "Your login informations are incorrect" in page:
+            self.wrongPassword()
+
+
+    def loadHosterList(self, req):
+        https = "https" if self.getConfig("https") else "http"
+        page = req.load(https + "://real-debrid.com/api/hosters.php").replace("\"","").strip()
+
+        return[x.strip() for x in page.split(",") if x.strip()]
\ No newline at end of file
diff --git a/module/plugins/hooks/AlldebridCom.py b/module/plugins/addons/AlldebridCom.py
index 6818b8c43..6818b8c43 100644
--- a/module/plugins/hooks/AlldebridCom.py
+++ b/module/plugins/addons/AlldebridCom.py
diff --git a/module/plugins/hooks/BypassCaptcha.py b/module/plugins/addons/BypassCaptcha.py
index 24ad17dd8..24ad17dd8 100644
--- a/module/plugins/hooks/BypassCaptcha.py
+++ b/module/plugins/addons/BypassCaptcha.py
diff --git a/module/plugins/hooks/CaptchaBrotherhood.py b/module/plugins/addons/CaptchaBrotherhood.py
index bdf547827..bdf547827 100644
--- a/module/plugins/hooks/CaptchaBrotherhood.py
+++ b/module/plugins/addons/CaptchaBrotherhood.py
diff --git a/module/plugins/hooks/CaptchaTrader.py b/module/plugins/addons/CaptchaTrader.py
index 2b8a50a8e..889fa38ef 100644
--- a/module/plugins/hooks/CaptchaTrader.py
+++ b/module/plugins/addons/CaptchaTrader.py
@@ -27,7 +27,7 @@ from pycurl import FORM_FILE, LOW_SPEED_TIME
 from module.network.RequestFactory import getURL, getRequest
 from module.network.HTTPRequest import BadHeader
 
-from module.plugins.Hook import Hook
+from module.plugins.Addon import Addon
 
 PYLOAD_KEY = "9f65e7f381c3af2b076ea680ae96b0b7"
 
@@ -44,7 +44,7 @@ class CaptchaTraderException(Exception):
     def __repr__(self):
         return "<CaptchaTraderException %s>" % self.err
 
-class CaptchaTrader(Hook):
+class CaptchaTrader(Addon):
     __name__ = "CaptchaTrader"
     __version__ = "0.14"
     __description__ = """send captchas to captchatrader.com"""
diff --git a/module/plugins/hooks/Checksum.py b/module/plugins/addons/Checksum.py
index b290838bb..b290838bb 100644
--- a/module/plugins/hooks/Checksum.py
+++ b/module/plugins/addons/Checksum.py
diff --git a/module/plugins/hooks/ClickAndLoad.py b/module/plugins/addons/ClickAndLoad.py
index 97e5cd57d..6d6928557 100644
--- a/module/plugins/hooks/ClickAndLoad.py
+++ b/module/plugins/addons/ClickAndLoad.py
@@ -21,9 +21,9 @@
 import socket
 import thread
 
-from module.plugins.Hook import Hook
+from module.plugins.Addon import Addon
 
-class ClickAndLoad(Hook):
+class ClickAndLoad(Addon):
     __name__ = "ClickAndLoad"
     __version__ = "0.2"
     __description__ = """Gives abillity to use jd's click and load. depends on webinterface"""
@@ -32,7 +32,7 @@ class ClickAndLoad(Hook):
     __author_name__ = ("RaNaN", "mkaay")
     __author_mail__ = ("RaNaN@pyload.de", "mkaay@mkaay.de")
 
-    def coreReady(self):
+    def activate(self):
         self.port = int(self.core.config['webinterface']['port'])
         if self.core.config['webinterface']['activated']:
             try:
diff --git a/module/plugins/hooks/DeathByCaptcha.py b/module/plugins/addons/DeathByCaptcha.py
index 59ff40ded..59ff40ded 100644
--- a/module/plugins/hooks/DeathByCaptcha.py
+++ b/module/plugins/addons/DeathByCaptcha.py
diff --git a/module/plugins/hooks/DownloadScheduler.py b/module/plugins/addons/DownloadScheduler.py
index 7cadede38..7cadede38 100644
--- a/module/plugins/hooks/DownloadScheduler.py
+++ b/module/plugins/addons/DownloadScheduler.py
diff --git a/module/plugins/hooks/EasybytezCom.py b/module/plugins/addons/EasybytezCom.py
index 6a4ded85b..6a4ded85b 100644
--- a/module/plugins/hooks/EasybytezCom.py
+++ b/module/plugins/addons/EasybytezCom.py
diff --git a/module/plugins/hooks/Ev0InFetcher.py b/module/plugins/addons/Ev0InFetcher.py
index 5941cf38c..608baf217 100644
--- a/module/plugins/hooks/Ev0InFetcher.py
+++ b/module/plugins/addons/Ev0InFetcher.py
@@ -18,18 +18,18 @@
 from module.lib import feedparser
 from time import mktime, time
 
-from module.plugins.Hook import Hook
+from module.plugins.Addon import Addon
 
-class Ev0InFetcher(Hook):
+class Ev0InFetcher(Addon):
     __name__ = "Ev0InFetcher"
     __version__ = "0.2"
     __description__ = """checks rss feeds for ev0.in"""
     __config__ = [("activated", "bool", "Activated", "False"),
                   ("interval", "int", "Check interval in minutes", "10"),
                   ("queue", "bool", "Move new shows directly to Queue", False),
-                  ("shows", "str", "Shows to check for (comma seperated)", ""),
+                  ("shows", "str", "Shows to check for (comma separated)", ""),
                   ("quality", "xvid;x264;rmvb", "Video Format", "xvid"),
-                  ("hoster", "str", "Hoster to use (comma seperated)", "NetloadIn,RapidshareCom,MegauploadCom,HotfileCom")]
+                  ("hoster", "str", "Hoster to use (comma separated)", "NetloadIn,RapidshareCom,MegauploadCom,HotfileCom")]
     __author_name__ = ("mkaay")
     __author_mail__ = ("mkaay@mkaay.de")
 
@@ -40,7 +40,7 @@ class Ev0InFetcher(Hook):
         results = self.core.pluginManager.parseUrls(links)
         sortedLinks = {}
         
-        for url, hoster in results:
+        for url, hoster in results[0]:
             if hoster not in sortedLinks:
                 sortedLinks[hoster] = []
             sortedLinks[hoster].append(url)
diff --git a/module/plugins/hooks/ExpertDecoders.py b/module/plugins/addons/ExpertDecoders.py
index 2e66e49ca..2e66e49ca 100644
--- a/module/plugins/hooks/ExpertDecoders.py
+++ b/module/plugins/addons/ExpertDecoders.py
diff --git a/module/plugins/hooks/ExternalScripts.py b/module/plugins/addons/ExternalScripts.py
index f46f290c0..8f5a5841e 100644
--- a/module/plugins/hooks/ExternalScripts.py
+++ b/module/plugins/addons/ExternalScripts.py
@@ -14,18 +14,17 @@
     You should have received a copy of the GNU General Public License
     along with this program; if not, see <http://www.gnu.org/licenses/>.
 
-    @author: mkaay
-    @interface-version: 0.1
+    @author: RaNaN
 """
 
 import subprocess
-from os import listdir, access, X_OK, makedirs
-from os.path import join, exists, basename
+from os import access, X_OK, makedirs
+from os.path import basename
 
-from module.plugins.Hook import Hook
-from module.utils import save_join
+from module.plugins.Addon import Addon
+from module.utils.fs import save_join, exists, join, listdir
 
-class ExternalScripts(Hook):
+class ExternalScripts(Addon):
     __name__ = "ExternalScripts"
     __version__ = "0.22"
     __description__ = """Run external scripts"""
diff --git a/module/plugins/hooks/ExtractArchive.py b/module/plugins/addons/ExtractArchive.py
index a5a973b7f..369b20ba9 100644
--- a/module/plugins/hooks/ExtractArchive.py
+++ b/module/plugins/addons/ExtractArchive.py
@@ -3,8 +3,7 @@
 
 import sys
 import os
-from os import remove, chmod, makedirs
-from os.path import exists, basename, isfile, isdir, join
+from os.path import basename, isfile, isdir, join
 from traceback import print_exc
 from copy import copy
 
@@ -49,11 +48,11 @@ if os.name != "nt":
     from pwd import getpwnam
     from grp import getgrnam
 
-from module.utils import save_join, fs_encode
-from module.plugins.Hook import Hook, threaded, Expose
+from module.utils.fs import save_join, fs_encode, exists, remove, chmod, makedirs
+from module.plugins.Addon import Addon, threaded, Expose
 from module.plugins.internal.AbstractExtractor import ArchiveError, CRCError, WrongPassword
 
-class ExtractArchive(Hook):
+class ExtractArchive(Addon):
     """
     Provides: unrarFinished (folder, filename)
     """
diff --git a/module/plugins/hooks/HotFolder.py b/module/plugins/addons/HotFolder.py
index ee1031ad5..d05026448 100644
--- a/module/plugins/hooks/HotFolder.py
+++ b/module/plugins/addons/HotFolder.py
@@ -26,9 +26,9 @@ from os.path import isfile
 from shutil import move
 import time
 
-from module.plugins.Hook import Hook
+from module.plugins.Addon import Addon
 
-class HotFolder(Hook):
+class HotFolder(Addon):
     __name__ = "HotFolder"
     __version__ = "0.1"
     __description__ = """observe folder and file for changes and add container and links"""
diff --git a/module/plugins/hooks/IRCInterface.py b/module/plugins/addons/IRCInterface.py
index a9fc11f53..c261fc6f3 100644
--- a/module/plugins/hooks/IRCInterface.py
+++ b/module/plugins/addons/IRCInterface.py
@@ -27,14 +27,14 @@ from time import sleep
 from traceback import print_exc
 import re
 
-from module.plugins.Hook import Hook
+from module.plugins.Addon import Addon
 from module.network.RequestFactory import getURL
 from module.utils import formatSize
 from module.Api import PackageDoesNotExists, FileDoesNotExists
 
 from pycurl import FORM_FILE
 
-class IRCInterface(Thread, Hook):
+class IRCInterface(Thread, Addon):
     __name__ = "IRCInterface"
     __version__ = "0.1"
     __description__ = """connect to irc and let owner perform different tasks"""
@@ -53,7 +53,7 @@ class IRCInterface(Thread, Hook):
     
     def __init__(self, core, manager):
         Thread.__init__(self)
-        Hook.__init__(self, core, manager)
+        Addon.__init__(self, core, manager)
         self.setDaemon(True)
         #   self.sm = core.server_methods
         self.api = core.api #todo, only use api
diff --git a/module/plugins/hooks/ImageTyperz.py b/module/plugins/addons/ImageTyperz.py
index 59b6334a7..59b6334a7 100644
--- a/module/plugins/hooks/ImageTyperz.py
+++ b/module/plugins/addons/ImageTyperz.py
diff --git a/module/plugins/hooks/LinkdecrypterCom.py b/module/plugins/addons/LinkdecrypterCom.py
index 2cb91d120..2cb91d120 100644
--- a/module/plugins/hooks/LinkdecrypterCom.py
+++ b/module/plugins/addons/LinkdecrypterCom.py
diff --git a/module/plugins/hooks/MergeFiles.py b/module/plugins/addons/MergeFiles.py
index 02d343096..48f997681 100644
--- a/module/plugins/hooks/MergeFiles.py
+++ b/module/plugins/addons/MergeFiles.py
@@ -24,11 +24,11 @@ import traceback
 
 from os.path import join
 from module.utils import save_join, fs_encode
-from module.plugins.Hook import Hook
+from module.plugins.Addon import Addon
 
 BUFFER_SIZE = 4096
 
-class MergeFiles(Hook):
+class MergeFiles(Addon):
     __name__ = "MergeFiles"
     __version__ = "0.1"
     __description__ = "Merges parts splitted with hjsplit"
diff --git a/module/plugins/hooks/MultiHome.py b/module/plugins/addons/MultiHome.py
index f15148538..af3f55416 100644
--- a/module/plugins/hooks/MultiHome.py
+++ b/module/plugins/addons/MultiHome.py
@@ -17,10 +17,10 @@
     @author: mkaay
 """
 
-from module.plugins.Hook import Hook
+from module.plugins.Addon import Addon
 from time import time
 
-class MultiHome(Hook):
+class MultiHome(Addon):
     __name__ = "MultiHome"
     __version__ = "0.1"
     __description__ = """ip address changer"""
diff --git a/module/plugins/addons/MultiHoster.py b/module/plugins/addons/MultiHoster.py
new file mode 100644
index 000000000..05d25b958
--- /dev/null
+++ b/module/plugins/addons/MultiHoster.py
@@ -0,0 +1,102 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import re
+from types import MethodType
+
+from module.plugins.MultiHoster import MultiHoster as MultiHosterAccount, normalize
+from module.plugins.Addon import Addon, AddEventListener
+from module.plugins.PluginManager import PluginTuple
+
+class MultiHoster(Addon):
+    __version__ = "0.1"
+    __internal__ = True
+    __description__ = "Gives ability to use MultiHoster services. You need to add your account first."
+    __config__ = []
+    __author_mail__ = ("pyLoad Team",)
+    __author_mail__ = ("support@pyload.org",)
+
+    #TODO: multiple accounts - multihoster / config options
+
+    def init(self):
+
+        # overwritten plugins
+        self.plugins = {}
+
+    def addHoster(self, account):
+
+        self.logDebug("New MultiHoster %s" % account.__name__)
+
+        pluginMap = {}
+        for name in self.core.pluginManager.getPlugins("hoster").keys():
+            pluginMap[name.lower()] = name
+
+        supported = []
+        new_supported = []
+
+        for hoster in account.getHosterList():
+            name = normalize(hoster)
+
+            if name in pluginMap:
+                supported.append(pluginMap[name])
+            else:
+                new_supported.append(hoster)
+
+        if not supported and not new_supported:
+            account.logError(_("No Hoster loaded"))
+            return
+
+        klass = self.core.pluginManager.getPluginClass(account.__name__)
+
+        # inject plugin plugin
+        account.logDebug("Overwritten Hosters: %s" % ", ".join(sorted(supported)))
+        for hoster in supported:
+            self.plugins[hoster] = klass
+
+        account.logDebug("New Hosters: %s" % ", ".join(sorted(new_supported)))
+
+        # create new regexp
+        regexp = r".*(%s).*" % "|".join([klass.__pattern__] + [x.replace(".", "\\.") for x in new_supported])
+
+        # recreate plugin tuple for new regexp
+        hoster = self.core.pluginManager.getPlugins("hoster")
+        p = hoster[account.__name__]
+        new = PluginTuple(p.version, re.compile(regexp), p.deps, p.user, p.path)
+        hoster[account.__name__] = new
+
+
+
+    @AddEventListener("accountDeleted")
+    def refreshAccounts(self, plugin=None, user=None):
+
+        self.plugins = {}
+
+        for name, account in self.core.accountManager.iterAccounts():
+            if isinstance(account, MultiHosterAccount) and account.isUsable():
+                self.addHoster(account)
+
+    @AddEventListener("accountUpdated")
+    def refreshAccount(self, plugin, user):
+
+        account = self.core.accountManager.getAccount(plugin, user)
+        if isinstance(account, MultiHosterAccount) and account.isUsable():
+            self.addHoster(account)
+
+    def activate(self):
+        self.refreshAccounts()
+
+        # new method for plugin manager
+        def getPlugin(self2, name):
+            if name in self.plugins:
+                return self.plugins[name]
+            return self2.getPluginClass(name)
+
+        pm = self.core.pluginManager
+        pm.getPlugin = MethodType(getPlugin, pm, object)
+
+
+    def deactivate(self):
+        #restore state
+        pm = self.core.pluginManager
+        pm.getPlugin = pm.getPluginClass
+
diff --git a/module/plugins/hooks/MultishareCz.py b/module/plugins/addons/MultishareCz.py
index 7e5a3e007..7e5a3e007 100644
--- a/module/plugins/hooks/MultishareCz.py
+++ b/module/plugins/addons/MultishareCz.py
diff --git a/module/plugins/hooks/Premium4Me.py b/module/plugins/addons/Premium4Me.py
index b49eb41a9..b49eb41a9 100644
--- a/module/plugins/hooks/Premium4Me.py
+++ b/module/plugins/addons/Premium4Me.py
diff --git a/module/plugins/hooks/PremiumizeMe.py b/module/plugins/addons/PremiumizeMe.py
index a10c24f85..a10c24f85 100644
--- a/module/plugins/hooks/PremiumizeMe.py
+++ b/module/plugins/addons/PremiumizeMe.py
diff --git a/module/plugins/hooks/RealdebridCom.py b/module/plugins/addons/RealdebridCom.py
index be74b47c3..be74b47c3 100644
--- a/module/plugins/hooks/RealdebridCom.py
+++ b/module/plugins/addons/RealdebridCom.py
diff --git a/module/plugins/hooks/RehostTo.py b/module/plugins/addons/RehostTo.py
index 7ca5e5cde..7ca5e5cde 100644
--- a/module/plugins/hooks/RehostTo.py
+++ b/module/plugins/addons/RehostTo.py
diff --git a/module/plugins/hooks/UnSkipOnFail.py b/module/plugins/addons/UnSkipOnFail.py
index 4b7a58be8..4b7a58be8 100644
--- a/module/plugins/hooks/UnSkipOnFail.py
+++ b/module/plugins/addons/UnSkipOnFail.py
diff --git a/module/plugins/hooks/UpdateManager.py b/module/plugins/addons/UpdateManager.py
index c800b44bf..c800b44bf 100644
--- a/module/plugins/hooks/UpdateManager.py
+++ b/module/plugins/addons/UpdateManager.py
diff --git a/module/plugins/hooks/XFileSharingPro.py b/module/plugins/addons/XFileSharingPro.py
index 105c70113..105c70113 100644
--- a/module/plugins/hooks/XFileSharingPro.py
+++ b/module/plugins/addons/XFileSharingPro.py
diff --git a/module/plugins/hooks/XMPPInterface.py b/module/plugins/addons/XMPPInterface.py
index a96adf524..e8ef1d2ca 100644
--- a/module/plugins/hooks/XMPPInterface.py
+++ b/module/plugins/addons/XMPPInterface.py
@@ -19,12 +19,12 @@
 """
 
 from pyxmpp import streamtls
-from pyxmpp.all import JID, Message
+from pyxmpp.all import JID, Message, Presence
 from pyxmpp.jabber.client import JabberClient
 from pyxmpp.interface import implements
 from pyxmpp.interfaces import *
 
-from module.plugins.hooks.IRCInterface import IRCInterface
+from module.plugins.addons.IRCInterface import IRCInterface
 
 class XMPPInterface(IRCInterface, JabberClient):
     __name__ = "XMPPInterface"
@@ -121,7 +121,26 @@ class XMPPInterface(IRCInterface, JabberClient):
         in a client session."""
         return [
                 ("normal", self.message),
-                                        ]
+                ]
+
+    def presence_control(self, stanza):
+        from_jid = unicode(stanza.get_from_jid())
+        stanza_type = stanza.get_type()
+        self.log.debug("pyLoad XMPP: %s stanza from %s" % (stanza_type,
+            from_jid))
+
+        if from_jid in self.getConfig("owners"):
+            return stanza.make_accept_response()
+
+        return stanza.make_deny_response()
+
+    def session_started(self):
+        self.stream.send(Presence())
+
+        self.stream.set_presence_handler("subscribe", self.presence_control)
+        self.stream.set_presence_handler("subscribed", self.presence_control)
+        self.stream.set_presence_handler("unsubscribe", self.presence_control)
+        self.stream.set_presence_handler("unsubscribed", self.presence_control)
 
     def message(self, stanza):
         """Message handler for the component."""
@@ -248,4 +267,10 @@ class VersionHandler(object):
         q.newTextChild(q.ns(), "name", "Echo component")
         q.newTextChild(q.ns(), "version", "1.0")
         return iq
-    
\ No newline at end of file
+
+    def unload(self):
+        self.log.debug("pyLoad XMPP: unloading")
+        self.disconnect()
+
+    def deactivate(self):
+        self.unload()
diff --git a/module/plugins/hooks/ZeveraCom.py b/module/plugins/addons/ZeveraCom.py
index cadf60069..cadf60069 100644
--- a/module/plugins/hooks/ZeveraCom.py
+++ b/module/plugins/addons/ZeveraCom.py
diff --git a/module/plugins/container/__init__.py b/module/plugins/addons/__init__.py
index e69de29bb..e69de29bb 100644
--- a/module/plugins/container/__init__.py
+++ b/module/plugins/addons/__init__.py
diff --git a/module/plugins/captcha/GigasizeCom.py b/module/plugins/captcha/GigasizeCom.py
deleted file mode 100644
index d31742eb5..000000000
--- a/module/plugins/captcha/GigasizeCom.py
+++ /dev/null
@@ -1,19 +0,0 @@
-# -*- coding: utf-8 -*-
-from captcha import OCR
-
-class GigasizeCom(OCR):
-    def __init__(self):
-        OCR.__init__(self)
-        
-    def get_captcha(self, image):
-        self.load_image(image)
-        self.threshold(2.8)
-        self.run_tesser(True, False, False, True)
-        return self.result_captcha
-
-if __name__ == '__main__':
-    ocr = GigasizeCom()
-    import urllib
-    urllib.urlretrieve('http://www.gigasize.com/randomImage.php', "gigasize_tmp.jpg")
-    
-    print ocr.get_captcha('gigasize_tmp.jpg')
diff --git a/module/plugins/captcha/LinksaveIn.py b/module/plugins/captcha/LinksaveIn.py
deleted file mode 100644
index 3ad7b265a..000000000
--- a/module/plugins/captcha/LinksaveIn.py
+++ /dev/null
@@ -1,147 +0,0 @@
-from captcha import OCR
-import Image
-from os import sep
-from os.path import dirname
-from os.path import abspath
-from glob import glob
-
-
-class LinksaveIn(OCR):
-    __name__ = "LinksaveIn"
-    def __init__(self):
-        OCR.__init__(self)
-        self.data_dir = dirname(abspath(__file__)) + sep + "LinksaveIn" + sep
-    
-    def load_image(self, image):
-        im = Image.open(image)
-        frame_nr = 0
-
-        lut = im.resize((256, 1))
-        lut.putdata(range(256))
-        lut = list(lut.convert("RGB").getdata())
-
-        new = Image.new("RGB", im.size)
-        npix = new.load()
-        while True:
-            try:
-                im.seek(frame_nr)
-            except EOFError:
-                break
-            frame = im.copy()
-            pix = frame.load()
-            for x in range(frame.size[0]):
-                for y in range(frame.size[1]):
-                    if lut[pix[x, y]] != (0,0,0):
-                        npix[x, y] = lut[pix[x, y]]
-            frame_nr += 1
-        new.save(self.data_dir+"unblacked.png")
-        self.image = new.copy()
-        self.pixels = self.image.load()
-        self.result_captcha = ''
-    
-    def get_bg(self):
-        stat = {}
-        cstat = {}
-        img = self.image.convert("P")
-        for bgpath in glob(self.data_dir+"bg/*.gif"):
-            stat[bgpath] = 0
-            bg = Image.open(bgpath)
-            
-            bglut = bg.resize((256, 1))
-            bglut.putdata(range(256))
-            bglut = list(bglut.convert("RGB").getdata())
-            
-            lut = img.resize((256, 1))
-            lut.putdata(range(256))
-            lut = list(lut.convert("RGB").getdata())
-            
-            bgpix = bg.load()
-            pix = img.load()
-            for x in range(bg.size[0]):
-                for y in range(bg.size[1]):
-                    rgb_bg = bglut[bgpix[x, y]]
-                    rgb_c = lut[pix[x, y]]
-                    try:
-                        cstat[rgb_c] += 1
-                    except:
-                        cstat[rgb_c] = 1
-                    if rgb_bg == rgb_c:
-                        stat[bgpath] += 1
-        max_p = 0
-        bg = ""
-        for bgpath, value in stat.items():
-            if max_p < value:
-                bg = bgpath
-                max_p = value
-        return bg
-    
-    def substract_bg(self, bgpath):
-        bg = Image.open(bgpath)
-        img = self.image.convert("P")
-        
-        bglut = bg.resize((256, 1))
-        bglut.putdata(range(256))
-        bglut = list(bglut.convert("RGB").getdata())
-        
-        lut = img.resize((256, 1))
-        lut.putdata(range(256))
-        lut = list(lut.convert("RGB").getdata())
-        
-        bgpix = bg.load()
-        pix = img.load()
-        orgpix = self.image.load()
-        for x in range(bg.size[0]):
-            for y in range(bg.size[1]):
-                rgb_bg = bglut[bgpix[x, y]]
-                rgb_c = lut[pix[x, y]]
-                if rgb_c == rgb_bg:
-                    orgpix[x, y] = (255,255,255)
-    
-    def eval_black_white(self):
-        new = Image.new("RGB", (140, 75))
-        pix = new.load()
-        orgpix = self.image.load()
-        thresh = 4
-        for x in range(new.size[0]):
-            for y in range(new.size[1]):
-                rgb = orgpix[x, y]
-                r, g, b = rgb
-                pix[x, y] = (255,255,255)
-                if r > max(b, g)+thresh:
-                    pix[x, y] = (0,0,0)
-                if g < min(r, b):
-                    pix[x, y] = (0,0,0)
-                if g > max(r, b)+thresh:
-                    pix[x, y] = (0,0,0)
-                if b > max(r, g)+thresh:
-                    pix[x, y] = (0,0,0)
-        self.image = new
-        self.pixels = self.image.load()
-    
-    def get_captcha(self, image):
-        self.load_image(image)
-        bg = self.get_bg()
-        self.substract_bg(bg)
-        self.eval_black_white()
-        self.to_greyscale()
-        self.image.save(self.data_dir+"cleaned_pass1.png")
-        self.clean(4)
-        self.clean(4)
-        self.image.save(self.data_dir+"cleaned_pass2.png")
-        letters = self.split_captcha_letters()
-        final = ""
-        for n, letter in enumerate(letters):
-            self.image = letter
-            self.image.save(ocr.data_dir+"letter%d.png" % n)
-            self.run_tesser(True, True, False, False)
-            final += self.result_captcha
-        
-        return final
-
-if __name__ == '__main__':
-    import urllib
-    ocr = LinksaveIn()
-    testurl = "http://linksave.in/captcha/cap.php?hsh=2229185&code=ZzHdhl3UffV3lXTH5U4b7nShXj%2Bwma1vyoNBcbc6lcc%3D"
-    urllib.urlretrieve(testurl, ocr.data_dir+"captcha.gif")
-    
-    print ocr.get_captcha(ocr.data_dir+'captcha.gif')
diff --git a/module/plugins/captcha/MegauploadCom.py b/module/plugins/captcha/MegauploadCom.py
deleted file mode 100644
index 469ee4094..000000000
--- a/module/plugins/captcha/MegauploadCom.py
+++ /dev/null
@@ -1,14 +0,0 @@
-from captcha import OCR
-
-class MegauploadCom(OCR):
-    __name__ = "MegauploadCom"
-    def __init__(self):
-        OCR.__init__(self)
-        
-    def get_captcha(self, image):
-        self.load_image(image)
-        self.run_tesser(True, True, False, True)
-        return self.result_captcha
-
-if __name__ == '__main__':
-    ocr = MegauploadCom()
diff --git a/module/plugins/container/LinkList.py b/module/plugins/container/LinkList.py
deleted file mode 100644
index fefeaf486..000000000
--- a/module/plugins/container/LinkList.py
+++ /dev/null
@@ -1,68 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-import codecs
-from module.utils import fs_encode
-from module.plugins.Container import Container
-
-class LinkList(Container):
-    __name__ = "LinkList"
-    __version__ = "0.12"
-    __pattern__ = r".+\.txt$"
-    __description__ = """Read Link Lists in txt format"""
-    __config__ = [("clear", "bool", "Clear Linklist after adding", False),
-                  ("encoding", "string", "File encoding (default utf-8)", "")]
-    __author_name__ = ("spoob", "jeix")
-    __author_mail__ = ("spoob@pyload.org", "jeix@hasnomail.com")
-
-    def decrypt(self, pyfile):
-        try:
-            file_enc = codecs.lookup(self.getConfig("encoding")).name
-        except:
-            file_enc = "utf-8"
-        
-        print repr(pyfile.url)
-        print pyfile.url
-        
-        file_name = fs_encode(pyfile.url)
-        
-        txt = codecs.open(file_name, 'r', file_enc)
-        links = txt.readlines()
-        curPack = "Parsed links from %s" % pyfile.name
-        
-        packages = {curPack:[],}
-        
-        for link in links:
-            link = link.strip()
-            if not link: continue
-            
-            if link.startswith(";"):
-                continue
-            if link.startswith("[") and link.endswith("]"):
-                # new package
-                curPack = link[1:-1]
-                packages[curPack] = []
-                continue
-            packages[curPack].append(link)
-        txt.close()
-        
-        # empty packages fix
-
-        delete = []
-        
-        for key,value in packages.iteritems():
-            if not value:
-                delete.append(key)
-                
-        for key in delete:
-            del packages[key]
-
-        if self.getConfig("clear"):
-            try:
-                txt = open(file_name, 'wb')
-                txt.close()
-            except:
-                self.log.warning(_("LinkList could not be cleared."))
-        
-        for name, links in packages.iteritems():
-            self.packages.append((name, links, name))
diff --git a/module/plugins/container/CCF.py b/module/plugins/crypter/CCF.py
index 301b033d4..ab7ff1099 100644
--- a/module/plugins/container/CCF.py
+++ b/module/plugins/crypter/CCF.py
@@ -4,13 +4,13 @@
 import re
 from urllib2 import build_opener
 
-from module.plugins.Container import Container
+from module.plugins.Crypter import Crypter
 from module.lib.MultipartPostHandler import MultipartPostHandler
 
 from os import makedirs
 from os.path import exists, join
 
-class CCF(Container):
+class CCF(Crypter):
     __name__ = "CCF"
     __version__ = "0.2"
     __pattern__ = r"(?!http://).*\.ccf$"
diff --git a/module/plugins/crypter/HoerbuchIn.py b/module/plugins/crypter/HoerbuchIn.py
index 4c26ba7f7..6f23b2eb9 100644
--- a/module/plugins/crypter/HoerbuchIn.py
+++ b/module/plugins/crypter/HoerbuchIn.py
@@ -10,7 +10,7 @@ class HoerbuchIn(Crypter):
     __name__ = "HoerbuchIn"
     __type__ = "container"
     __pattern__ = r"http://(www\.)?hoerbuch\.in/(wp/horbucher/\d+/.+/|tp/out.php\?.+|protection/folder_\d+\.html)"
-    __version__ = "0.6"
+    __version__ = "0.7"
     __description__ = """Hoerbuch.in Container Plugin"""
     __author_name__ = ("spoob", "mkaay")
     __author_mail__ = ("spoob@pyload.org", "mkaay@mkaay.de")
@@ -46,10 +46,10 @@ class HoerbuchIn(Crypter):
         src = self.req.load(url, post={"viewed": "adpg"})
         
         links = []
-        pattern = re.compile("http://www\.hoerbuch\.in/protection/(\w+)/(.*?)\"")
-        for hoster, lid in pattern.findall(src):
+        pattern = re.compile(r'<div class="container"><a href="(.*?)"')
+        for hoster_url in pattern.findall(src):
             self.req.lastURL = url
-            self.load("http://www.hoerbuch.in/protection/%s/%s" % (hoster, lid))
+            self.load(hoster_url)
             links.append(self.req.lastEffectiveURL)
         
         return links
diff --git a/module/plugins/crypter/HotfileFolderCom.py b/module/plugins/crypter/HotfileFolderCom.py
index 00771e2a3..ea7311e3c 100644
--- a/module/plugins/crypter/HotfileFolderCom.py
+++ b/module/plugins/crypter/HotfileFolderCom.py
@@ -9,17 +9,21 @@ class HotfileFolderCom(Crypter):
     __name__ = "HotfileFolderCom"
     __type__ = "crypter"
     __pattern__ = r"http://(?:www\.)?hotfile.com/list/\w+/\w+"
-    __version__ = "0.1"
+    __version__ = "0.2"
     __description__ = """HotfileFolder Download Plugin"""
     __author_name__ = ("RaNaN")
     __author_mail__ = ("RaNaN@pyload.org")
 
-    def decrypt(self, pyfile):
-        html = self.load(pyfile.url)
+    def decryptURL(self, url):
+        html = self.load(url)
 
-        name = re.findall(r'<img src="/i/folder.gif" width="23" height="14" style="margin-bottom: -2px;" />([^<]+)', html, re.MULTILINE)[0].replace("/", "")
-        new_links = re.findall(r'href="(http://(www.)?hotfile\.com/dl/\d+/[0-9a-zA-Z]+[^"]+)', html)
+        new_links = []
+        for link in re.findall(r'href="(http://(www.)?hotfile\.com/dl/\d+/[0-9a-zA-Z]+[^"]+)', html):
+            new_links.append(link[0])
 
-        new_links = [x[0] for x in new_links]
+        if new_links:
+            self.logDebug("Found %d new links" % len(new_links))
+            return new_links
+        else:
+            self.fail('Could not extract any links')
 
-        self.packages.append((name, new_links, name))
\ No newline at end of file
diff --git a/module/plugins/crypter/LinkList.py b/module/plugins/crypter/LinkList.py
new file mode 100644
index 000000000..ebfa373eb
--- /dev/null
+++ b/module/plugins/crypter/LinkList.py
@@ -0,0 +1,55 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from module.plugins.Crypter import Crypter, Package
+
+class LinkList(Crypter):
+    __name__ = "LinkList"
+    __version__ = "0.11"
+    __pattern__ = r".+\.txt$"
+    __description__ = """Read Link Lists in txt format"""
+    __author_name__ = ("spoob", "jeix")
+    __author_mail__ = ("spoob@pyload.org", "jeix@hasnomail.com")
+
+    # method declaration is needed here
+    def decryptURL(self, url):
+        return Crypter.decryptURL(self, url)
+
+    def decryptFile(self, content):
+        links = content.splitlines()
+
+        curPack = "default"
+        packages = {curPack:[]}
+        
+        for link in links:
+            link = link.strip()
+            if not link: continue
+            
+            if link.startswith(";"):
+                continue
+            if link.startswith("[") and link.endswith("]"):
+                # new package
+                curPack = link[1:-1]
+                packages[curPack] = []
+                continue
+            packages[curPack].append(link)
+        
+        # empty packages fix
+        delete = []
+        
+        for key,value in packages.iteritems():
+            if not value:
+                delete.append(key)
+                
+        for key in delete:
+            del packages[key]
+
+        urls = []
+
+        for name, links in packages.iteritems():
+            if name == "default":
+                urls.extend(links)
+            else:
+                urls.append(Package(name, links))
+
+        return urls
\ No newline at end of file
diff --git a/module/plugins/crypter/OronComFolder.py b/module/plugins/crypter/OronComFolder.py
index 57b273163..726371966 100755
--- a/module/plugins/crypter/OronComFolder.py
+++ b/module/plugins/crypter/OronComFolder.py
@@ -8,25 +8,39 @@ class OronComFolder(Crypter):
     __name__ = "OronComFolder"
     __type__ = "crypter"
     __pattern__ = r"http://(?:www\.)?oron.com/folder/\w+"
-    __version__ = "0.1"
+    __version__ = "0.2"
     __description__ = """Oron.com Folder Plugin"""
     __author_name__ = ("DHMH")
     __author_mail__ = ("webmaster@pcProfil.de")
 
-    FOLDER_PATTERN = r'<table width="100%" cellpadding="7" cellspacing="1" class="tbl2">(.*)</table>\n		</div>'
+    FOLDER_PATTERN = r'<table(?:.*)class="tbl"(?:.*)>(?:.*)<table(?:.*)class="tbl2"(?:.*)>(?P<body>.*)</table>(?:.*)</table>'
     LINK_PATTERN = r'<a href="([^"]+)" target="_blank">'
 
-    def decrypt(self, pyfile):
-        html = self.load(self.pyfile.url)
+    def decryptURL(self, url):
+        html = self.load(url)
 
         new_links = []
 
+        if 'No such folder exist' in html:
+            # Don't fail because if there's more than a folder for this package
+            # and only one of them fails, no urls at all will be added.
+            self.logWarning("Folder does not exist")
+            return new_links
+
         folder = re.search(self.FOLDER_PATTERN, html, re.DOTALL)
-        if folder is None: self.fail("Parse error (FOLDER)")
+        if folder is None:
+            # Don't fail because if there's more than a folder for this package
+            # and only one of them fails, no urls at all will be added.
+            self.logWarning("Parse error (FOLDER)")
+            return new_links
         
         new_links.extend(re.findall(self.LINK_PATTERN, folder.group(0)))
         
         if new_links:
-            self.core.files.addLinks(new_links, self.pyfile.package().id)
+            self.logDebug("Found %d new links" % len(new_links))
+            return new_links
         else:
-            self.fail('Could not extract any links')
\ No newline at end of file
+            # Don't fail because if there's more than a folder for this package
+            # and only one of them fails, no urls at all will be added.
+            self.logWarning('Could not extract any links')
+            return new_links
diff --git a/module/plugins/container/RSDF.py b/module/plugins/crypter/RSDF.py
index ea5cd67f2..cbc9864b1 100644
--- a/module/plugins/container/RSDF.py
+++ b/module/plugins/crypter/RSDF.py
@@ -5,9 +5,9 @@ import base64
 import binascii
 import re
 
-from module.plugins.Container import Container
+from module.plugins.Crypter import Crypter
 
-class RSDF(Container):
+class RSDF(Crypter):
     __name__ = "RSDF"
     __version__ = "0.21"
     __pattern__ = r".*\.rsdf"
diff --git a/module/plugins/crypter/XfilesharingProFolder.py b/module/plugins/crypter/XfilesharingProFolder.py
new file mode 100644
index 000000000..8e58c207d
--- /dev/null
+++ b/module/plugins/crypter/XfilesharingProFolder.py
@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-

+

+from module.plugins.Crypter import Crypter, Package

+import re

+

+class XfilesharingProFolder(Crypter):

+    __name__ = "XfilesharingProFolder"

+    __type__ = "crypter"

+    __pattern__ = r"http://(?:www\.)?((easybytez|turboupload|uploadville|file4safe|fileband|filebeep|grupload|247upload)\.com|(muchshare|annonhost).net|bzlink.us)/users/.*"  

+    __version__ = "0.01"

+    __description__ = """Generic XfilesharingPro Folder Plugin"""

+    __author_name__ = ("zoidberg")

+    __author_mail__ = ("zoidberg@mujmail.cz")

+

+    LINK_PATTERN = r'<div class="link"><a href="([^"]+)" target="_blank">[^<]*</a></div>'

+    SUBFOLDER_PATTERN = r'<TD width="1%"><img src="[^"]*/images/folder2.gif"></TD><TD><a href="([^"]+)"><b>(?!\. \.<)([^<]+)</b></a></TD>' 

+  

+    def decryptURL(self, url):

+        return self.decryptFile(self.load(url, decode = True))

+

+    def decryptFile(self, html):

+        new_links = []

+

+        new_links.extend(re.findall(self.LINK_PATTERN, html))

+        

+        subfolders = re.findall(self.SUBFOLDER_PATTERN, html)

+        #self.logDebug(subfolders)        

+        for (url, name) in subfolders:

+            if self.package: name = "%s/%s" % (self.package.name, name)                 

+            new_links.append(Package(name, [url]))        

+           

+        if not new_links: self.fail('Could not extract any links')

+    

+        return new_links
\ No newline at end of file
diff --git a/module/plugins/hoster/BasePlugin.py b/module/plugins/hoster/BasePlugin.py
index f8d494e39..7070fafde 100644
--- a/module/plugins/hoster/BasePlugin.py
+++ b/module/plugins/hoster/BasePlugin.py
@@ -29,12 +29,11 @@ class BasePlugin(Hoster):
             self.multiDL = False
             return
 
-#        self.__name__ = "NetloadIn"
-#        pyfile.name = "test"
-#        self.html = self.load("http://localhost:9000/short")
-#        self.download("http://localhost:9000/short")
-#        self.api = self.load("http://localhost:9000/short")
-#        self.decryptCaptcha("http://localhost:9000/captcha")
+        #TODO: remove debug
+        if pyfile.url.lower().startswith("debug"):
+            self.decryptCaptcha("http://download.pyload.org/pie.png", imgtype="png")
+            self.download("http://download.pyload.org/random100.bin")
+            return
 #
 #        if pyfile.url == "79":
 #            self.core.api.addPackage("test", [str(i) for i in range(80)], 1)
@@ -96,10 +95,10 @@ class BasePlugin(Hoster):
                 disp = m.groupdict()
                 self.logDebug(disp)
                 if not disp['enc']: disp['enc'] = 'utf-8'
-                name = remove_chars(disp['name'], "\"';").strip()
+                name = remove_chars(disp['name'], "\"';/").strip()
                 name = unicode(unquote(name), disp['enc'])
 
         if not name: name = url
         pyfile.name = name
         self.logDebug("Filename: %s" % pyfile.name)
-        self.download(url, disposition=True)
\ No newline at end of file
+        self.download(url, disposition=True)
diff --git a/module/plugins/hoster/BezvadataCz.py b/module/plugins/hoster/BezvadataCz.py
index cb9bae07c..49299d463 100644
--- a/module/plugins/hoster/BezvadataCz.py
+++ b/module/plugins/hoster/BezvadataCz.py
@@ -1,4 +1,4 @@
-# -*- coding: utf-8 -*-
+# -*- coding: utf-8 -*-
 """
     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
diff --git a/module/plugins/hoster/DlFreeFr.py b/module/plugins/hoster/DlFreeFr.py
index 44906e7e8..67c2d6c17 100644
--- a/module/plugins/hoster/DlFreeFr.py
+++ b/module/plugins/hoster/DlFreeFr.py
@@ -103,7 +103,6 @@ class DlFreeFr(SimpleHoster):
     #FILE_URL_PATTERN = r'href="(?P<url>http://.*?)">T&eacute;l&eacute;charger ce fichier'   
                     
     def setup(self):
-        self.multiDL = True
         self.limitDL = 5
         self.resumeDownload = True
         self.chunkLimit = 1        
diff --git a/module/plugins/hoster/FilesMailRu.py b/module/plugins/hoster/FilesMailRu.py
index 5f36de3c4..ee4ea4953 100644
--- a/module/plugins/hoster/FilesMailRu.py
+++ b/module/plugins/hoster/FilesMailRu.py
@@ -2,9 +2,8 @@
 # -*- coding: utf-8 -*-
 
 import re
-from module.plugins.Hoster import Hoster
+from module.plugins.Hoster import Hoster, chunks
 from module.network.RequestFactory import getURL
-from module.plugins.Plugin import chunks
 
 def getInfo(urls):
     result = []
diff --git a/module/plugins/hoster/HotfileCom.py b/module/plugins/hoster/HotfileCom.py
index 902a5601b..2caf1ffbc 100644
--- a/module/plugins/hoster/HotfileCom.py
+++ b/module/plugins/hoster/HotfileCom.py
@@ -6,7 +6,7 @@ from module.plugins.Hoster import Hoster
 from module.plugins.ReCaptcha import ReCaptcha
 
 from module.network.RequestFactory import getURL
-from module.plugins.Plugin import chunks
+from module.utils import chunks
 
 def getInfo(urls):
     api_url_base = "http://api.hotfile.com/"
diff --git a/module/plugins/hoster/MultishareCz.py b/module/plugins/hoster/MultishareCz.py
index a0dda30b8..af7aa94cf 100644
--- a/module/plugins/hoster/MultishareCz.py
+++ b/module/plugins/hoster/MultishareCz.py
@@ -24,7 +24,7 @@ class MultishareCz(SimpleHoster):
     __name__ = "MultishareCz"
     __type__ = "hoster"
     __pattern__ = r"http://(?:\w*\.)?multishare.cz/stahnout/(?P<ID>\d+).*"
-    __version__ = "0.34"
+    __version__ = "0.40"
     __description__ = """MultiShare.cz"""
     __author_name__ = ("zoidberg")
 
@@ -50,11 +50,12 @@ class MultishareCz(SimpleHoster):
         self.download("http://www.multishare.cz/html/download_free.php?ID=%s" % self.fileID)
         
     def handlePremium(self):
-        if not self.checkCredit():
+        if not self.checkTrafficLeft():
             self.logWarning("Not enough credit left to download file")
             self.resetAccount() 
                 
         self.download("http://www.multishare.cz/html/download_premium.php?ID=%s" % self.fileID)
+        self.checkTrafficLeft()
     
     def handleOverriden(self):
         if not self.premium: 
@@ -63,18 +64,13 @@ class MultishareCz(SimpleHoster):
         self.html = self.load('http://www.multishare.cz/html/mms_ajax.php', post = {"link": self.pyfile.url}, decode = True)        
         self.getFileInfo()       
         
-        if not self.checkCredit():
+        if not self.checkTrafficLeft():
             self.fail("Not enough credit left to download file")
         
         url = "http://dl%d.mms.multishare.cz/html/mms_process.php" % round(random()*10000*random())    
         params = {"u_ID" : self.acc_info["u_ID"], "u_hash" : self.acc_info["u_hash"], "link" : self.pyfile.url}
         self.logDebug(url, params)
         self.download(url, get = params)
-    
-    def checkCredit(self):                   
-        self.acc_info = self.account.getAccountInfo(self.user, True)
-        self.logInfo("User %s has %i MB left" % (self.user, self.acc_info["trafficleft"]/1024))
-                
-        return self.pyfile.size / 1024 <= self.acc_info["trafficleft"]
+        self.checkTrafficLeft()
 
 getInfo = create_getInfo(MultishareCz)
\ No newline at end of file
diff --git a/module/plugins/hoster/NetloadIn.py b/module/plugins/hoster/NetloadIn.py
index d2bf37d70..fd38be8c0 100644
--- a/module/plugins/hoster/NetloadIn.py
+++ b/module/plugins/hoster/NetloadIn.py
@@ -5,14 +5,12 @@ import re
 from time import sleep, time
 
 
+from module.utils import chunks
 from module.plugins.Hoster import Hoster
 from module.network.RequestFactory import getURL
-from module.plugins.Plugin import chunks
-
-
 
 def getInfo(urls):
- ##  returns list of tupels (name, size (in bytes), status (see FileDatabase), url)
+ ##  returns list of tuples (name, size (in bytes), status (see FileDatabase), url)
 
 
     apiurl = "http://api.netload.in/info.php?auth=Zf9SnQh9WiReEsb18akjvQGqT0I830e8&bz=1&md5=1&file_id="
@@ -206,7 +204,7 @@ class NetloadIn(Hoster):
             file_id = re.search('<input name="file_id" type="hidden" value="(.*)" />', page).group(1)
             if not captchawaited:
                 wait = self.get_wait_time(page)
-                if i == 0: self.pyfile.waitUntil = time() # dont wait contrary to time on website
+                if i == 0: self.pyfile.waitUntil = time() # don't wait contrary to time on web site
                 else: self.pyfile.waitUntil = t
                 self.log.info(_("Netload: waiting for captcha %d s.") % (self.pyfile.waitUntil - time()))
                 #self.setWait(wait)
diff --git a/module/plugins/hoster/RapidshareCom.py b/module/plugins/hoster/RapidshareCom.py
index 8b31dd42c..6aacd684e 100644
--- a/module/plugins/hoster/RapidshareCom.py
+++ b/module/plugins/hoster/RapidshareCom.py
@@ -52,7 +52,7 @@ class RapidshareCom(Hoster):
     __pattern__ = r"https?://[\w\.]*?rapidshare.com/(?:files/(?P<id>\d*?)/(?P<name>[^?]+)|#!download\|(?:\w+)\|(?P<id_new>\d+)\|(?P<name_new>[^|]+))"
     __version__ = "1.38"
     __description__ = """Rapidshare.com Download Hoster"""
-    __config__ = [["server", "Cogent;Deutsche Telekom;Level(3);Level(3) #2;GlobalCrossing;Level(3) #3;Teleglobe;GlobalCrossing #2;TeliaSonera #2;Teleglobe #2;TeliaSonera #3;TeliaSonera", "Preferred Server", "None"]] 
+    __config__ = [("server", "Cogent;Deutsche Telekom;Level(3);Level(3) #2;GlobalCrossing;Level(3) #3;Teleglobe;GlobalCrossing #2;TeliaSonera #2;Teleglobe #2;TeliaSonera #3;TeliaSonera", "Preferred Server", "None")]
     __author_name__ = ("spoob", "RaNaN", "mkaay")
     __author_mail__ = ("spoob@pyload.org", "ranan@pyload.org", "mkaay@mkaay.de")
 
@@ -129,7 +129,7 @@ class RapidshareCom(Hoster):
             self.handleFree()
 
     def handlePremium(self):
-        info = self.account.getAccountInfo(self.user, True)
+        info = self.account.getAccountInfo(True)
         self.log.debug("%s: Use Premium Account" % self.__name__)
         url = self.api_data["mirror"]
         self.download(url, get={"directstart":1})
diff --git a/module/plugins/hoster/RealdebridCom.py b/module/plugins/hoster/RealdebridCom.py
index ff4843afd..3c796232e 100644
--- a/module/plugins/hoster/RealdebridCom.py
+++ b/module/plugins/hoster/RealdebridCom.py
@@ -1,88 +1,88 @@
-#!/usr/bin/env python

-# -*- coding: utf-8 -*-

-

-import re

-from time import time

-from urllib import quote, unquote

-from random import randrange

-

-from module.utils import parseFileSize, remove_chars

-from module.common.json_layer import json_loads

-from module.plugins.Hoster import Hoster

-

-class RealdebridCom(Hoster):

-    __name__ = "RealdebridCom"

-    __version__ = "0.49"

-    __type__ = "hoster"

-

-    __pattern__ = r"https?://.*real-debrid\..*"

-    __description__ = """Real-Debrid.com hoster plugin"""

-    __author_name__ = ("Devirex, Hazzard")

-    __author_mail__ = ("naibaf_11@yahoo.de")

-

-    def getFilename(self, url):

-        try:

-            name = unquote(url.rsplit("/", 1)[1])

-        except IndexError:

-            name = "Unknown_Filename..."

-        if not name or name.endswith(".."): #incomplete filename, append random stuff

-            name += "%s.tmp" % randrange(100,999)

-        return name

-

-    def init(self):

-        self.tries = 0

-        self.chunkLimit = 3

-        self.resumeDownload = True

-

-

-    def process(self, pyfile):

-        if not self.account:

-            self.logError(_("Please enter your Real-debrid account or deactivate this plugin"))

-            self.fail("No Real-debrid account provided")

-

-        self.log.debug("Real-Debrid: Old URL: %s" % pyfile.url)

-        if re.match(self.__pattern__, pyfile.url):

-            new_url = pyfile.url

-        else:

-            password = self.getPassword().splitlines()

-            if not password: password = ""

-            else: password = password[0]

-

-            url = "http://real-debrid.com/ajax/unrestrict.php?lang=en&link=%s&password=%s&time=%s" % (quote(pyfile.url, ""), password, int(time()*1000))

-            page = self.load(url)

-            data = json_loads(page)

-

-            self.logDebug("Returned Data: %s" % data)

-

-            if data["error"] != 0:

-                if data["message"] == "Your file is unavailable on the hoster.":

-                    self.offline()

-                else:

-                    self.logWarning(data["message"])

-                    self.tempOffline()

-            else:

-                if self.pyfile.name is not None and self.pyfile.name.endswith('.tmp') and data["file_name"]:

-                    self.pyfile.name = data["file_name"]

-                self.pyfile.size = parseFileSize(data["file_size"])

-                new_url = data['generated_links'][0][-1]

-

-        if self.getConfig("https"):

-            new_url = new_url.replace("http://", "https://")

-        else:

-            new_url = new_url.replace("https://", "http://")

-

-        self.log.debug("Real-Debrid: New URL: %s" % new_url)

-

-        if pyfile.name.startswith("http") or pyfile.name.startswith("Unknown") or pyfile.name.endswith('..'):

-            #only use when name wasnt already set

-            pyfile.name = self.getFilename(new_url)

-

-        self.download(new_url, disposition=True)

-

-        check = self.checkDownload(

-                {"error": "<title>An error occured while processing your request</title>"})

-

-        if check == "error":

-            #usual this download can safely be retried

-            self.retry(reason="An error occured while generating link.", wait_time=60)

-

+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import re
+from time import time
+from urllib import quote, unquote
+from random import randrange
+
+from module.utils import parseFileSize, remove_chars
+from module.common.json_layer import json_loads
+from module.plugins.Hoster import Hoster
+
+class RealdebridCom(Hoster):
+    __name__ = "RealdebridCom"
+    __version__ = "0.49"
+    __type__ = "hoster"
+
+    __pattern__ = r"https?://.*real-debrid\..*"
+    __description__ = """Real-Debrid.com hoster plugin"""
+    __author_name__ = ("Devirex, Hazzard")
+    __author_mail__ = ("naibaf_11@yahoo.de")
+
+    def getFilename(self, url):
+        try:
+            name = unquote(url.rsplit("/", 1)[1])
+        except IndexError:
+            name = "Unknown_Filename..."
+        if not name or name.endswith(".."): #incomplete filename, append random stuff
+            name += "%s.tmp" % randrange(100,999)
+        return name
+
+    def init(self):
+        self.tries = 0
+        self.chunkLimit = 3
+        self.resumeDownload = True
+
+
+    def process(self, pyfile):
+        if not self.account:
+            self.logError(_("Please enter your Real-debrid account or deactivate this plugin"))
+            self.fail("No Real-debrid account provided")
+
+        self.log.debug("Real-Debrid: Old URL: %s" % pyfile.url)
+        if re.match(self.__pattern__, pyfile.url):
+            new_url = pyfile.url
+        else:
+            password = self.getPassword().splitlines()
+            if not password: password = ""
+            else: password = password[0]
+
+            url = "http://real-debrid.com/ajax/unrestrict.php?lang=en&link=%s&password=%s&time=%s" % (quote(pyfile.url, ""), password, int(time()*1000))
+            page = self.load(url)
+            data = json_loads(page)
+
+            self.logDebug("Returned Data: %s" % data)
+
+            if data["error"] != 0:
+                if data["message"] == "Your file is unavailable on the hoster.":
+                    self.offline()
+                else:
+                    self.logWarning(data["message"])
+                    self.tempOffline()
+            else:
+                if self.pyfile.name is not None and self.pyfile.name.endswith('.tmp') and data["file_name"]:
+                    self.pyfile.name = data["file_name"]
+                self.pyfile.size = parseFileSize(data["file_size"])
+                new_url = data['generated_links'][0][-1]
+
+        if self.getConfig("https"):
+            new_url = new_url.replace("http://", "https://")
+        else:
+            new_url = new_url.replace("https://", "http://")
+
+        self.log.debug("Real-Debrid: New URL: %s" % new_url)
+
+        if pyfile.name.startswith("http") or pyfile.name.startswith("Unknown") or pyfile.name.endswith('..'):
+            #only use when name wasnt already set
+            pyfile.name = self.getFilename(new_url)
+
+        self.download(new_url, disposition=True)
+
+        check = self.checkDownload(
+                {"error": "<title>An error occured while processing your request</title>"})
+
+        if check == "error":
+            #usual this download can safely be retried
+            self.retry(reason="An error occured while generating link.", wait_time=60)
+
diff --git a/module/plugins/hoster/UploadedTo.py b/module/plugins/hoster/UploadedTo.py
index a2134ecb5..ae70b1471 100644
--- a/module/plugins/hoster/UploadedTo.py
+++ b/module/plugins/hoster/UploadedTo.py
@@ -2,11 +2,10 @@
 
 import re
 
-from module.utils import html_unescape, parseFileSize
+from module.utils import html_unescape, parseFileSize, chunks
 
 from module.plugins.Hoster import Hoster
 from module.network.RequestFactory import getURL
-from module.plugins.Plugin import chunks
 from module.plugins.ReCaptcha import ReCaptcha
 
 key = "bGhGMkllZXByd2VEZnU5Y2NXbHhYVlZ5cEE1bkEzRUw=".decode('base64')
diff --git a/module/plugins/hoster/ZeveraCom.py b/module/plugins/hoster/ZeveraCom.py
index cbedfcb68..8be725d2f 100644
--- a/module/plugins/hoster/ZeveraCom.py
+++ b/module/plugins/hoster/ZeveraCom.py
@@ -1,108 +1,108 @@
-#!/usr/bin/env python

-# -*- coding: utf-8 -*-

-

-from module.plugins.Hoster import Hoster

-from module.utils import html_unescape

-from urllib import quote, unquote

-from time import sleep

-

-class ZeveraCom(Hoster):

-    __name__ = "ZeveraCom"

-    __version__ = "0.20"

-    __type__ = "hoster"

-    __pattern__ = r"http://zevera.com/.*"

-    __description__ = """zevera.com hoster plugin"""

-    __author_name__ = ("zoidberg")

-    __author_mail__ = ("zoidberg@mujmail.cz")

-    

-    def setup(self):

-        self.resumeDownload = self.multiDL = True

-        self.chunkLimit = 1

-    

-    def process(self, pyfile):

-        if not self.account:

-            self.logError(_("Please enter your zevera.com account or deactivate this plugin"))

-            self.fail("No zevera.com account provided")

-

-        self.logDebug("zevera.com: Old URL: %s" % pyfile.url)

-        

-        if self.account.getAPIData(self.req, cmd = "checklink", olink = pyfile.url) != "Alive":

-            self.fail("Offline or not downloadable - contact Zevera support")                 

-        

-        header = self.account.getAPIData(self.req, just_header = True, cmd="generatedownloaddirect", olink = pyfile.url)

-        if not "location" in header:

-            self.fail("Unable to initialize download - contact Zevera support")

-        

-        self.download(header['location'], disposition = True)

-        

-        check = self.checkDownload({"error" : 'action="ErrorDownload.aspx'})

-        if check == "error":

-            self.fail("Error response received - contact Zevera support")

-                            

-    """

-    # BitAPI not used - defunct, probably abandoned by Zevera

-    

-    api_url = "http://zevera.com/API.ashx"        

-    

-    def process(self, pyfile): 

-        if not self.account:

-            self.logError(_("Please enter your zevera.com account or deactivate this plugin"))

-            self.fail("No zevera.com account provided")

-

-        self.logDebug("zevera.com: Old URL: %s" % pyfile.url)

-        

-        last_size = retries = 0

-        olink = self.pyfile.url #quote(self.pyfile.url.encode('utf_8'))

-        

-        for i in range(100):

-            self.retData = self.account.loadAPIRequest(self.req, cmd = 'download_request', olink = olink)       

-            self.checkAPIErrors(self.retData)

-            

-            if self.retData['FileInfo']['StatusID'] == 100: 

-                break

-            elif self.retData['FileInfo']['StatusID'] == 99:

-                self.fail('Failed to initialize download (99)')              

-            else:               

-                if self.retData['FileInfo']['Progress']['BytesReceived'] <= last_size: 

-                    if retries >= 6:

-                        self.fail('Failed to initialize download (%d)' % self.retData['FileInfo']['StatusID'] )

-                    retries += 1

-                else:               

-                    retries = 0

-                

-                last_size = self.retData['FileInfo']['Progress']['BytesReceived']

-                

-                self.setWait(self.retData['Update_Wait'])

-                self.wait()                

-        

-        pyfile.name = self.retData['FileInfo']['RealFileName']

-        pyfile.size = self.retData['FileInfo']['FileSizeInBytes'] 

-        

-        self.retData = self.account.loadAPIRequest(self.req, cmd = 'download_start', FileID = self.retData['FileInfo']['FileID'])

-        self.checkAPIErrors(self.retData)

-        

-        self.download(self.api_url, get = {

-            'cmd': "open_stream",

-            'login': self.account.loginname,

-            'pass': self.account.password,

-            'FileID': self.retData['FileInfo']['FileID'],

-            'startBytes': 0

-            }

-        )                        

-

-    def checkAPIErrors(self, retData):

-        if not retData: 

-            self.fail('Unknown API response')

-            

-        if retData['ErrorCode']: 

-            self.logError(retData['ErrorCode'], retData['ErrorMessage'])

-            #self.fail('ERROR: ' + retData['ErrorMessage'])

-            

-        if self.pyfile.size / 1024000 > retData['AccountInfo']['AvailableTODAYTrafficForUseInMBytes']:

-            self.logWarning("Not enough data left to download the file")

-    

-    def crazyDecode(self, ustring):       

-        # accepts decoded ie. unicode string - API response is double-quoted, double-utf8-encoded

-        # no idea what the proper order of calling these functions would be :-/

-        return html_unescape(unquote(unquote(ustring.replace('@DELIMITER@','#'))).encode('raw_unicode_escape').decode('utf-8'))

+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from module.plugins.Hoster import Hoster
+from module.utils import html_unescape
+from urllib import quote, unquote
+from time import sleep
+
+class ZeveraCom(Hoster):
+    __name__ = "ZeveraCom"
+    __version__ = "0.20"
+    __type__ = "hoster"
+    __pattern__ = r"http://zevera.com/.*"
+    __description__ = """zevera.com hoster plugin"""
+    __author_name__ = ("zoidberg")
+    __author_mail__ = ("zoidberg@mujmail.cz")
+    
+    def setup(self):
+        self.resumeDownload = self.multiDL = True
+        self.chunkLimit = 1
+    
+    def process(self, pyfile):
+        if not self.account:
+            self.logError(_("Please enter your zevera.com account or deactivate this plugin"))
+            self.fail("No zevera.com account provided")
+
+        self.logDebug("zevera.com: Old URL: %s" % pyfile.url)
+        
+        if self.account.getAPIData(self.req, cmd = "checklink", olink = pyfile.url) != "Alive":
+            self.fail("Offline or not downloadable - contact Zevera support")                 
+        
+        header = self.account.getAPIData(self.req, just_header = True, cmd="generatedownloaddirect", olink = pyfile.url)
+        if not "location" in header:
+            self.fail("Unable to initialize download - contact Zevera support")
+        
+        self.download(header['location'], disposition = True)
+        
+        check = self.checkDownload({"error" : 'action="ErrorDownload.aspx'})
+        if check == "error":
+            self.fail("Error response received - contact Zevera support")
+                            
+    """
+    # BitAPI not used - defunct, probably abandoned by Zevera
+    
+    api_url = "http://zevera.com/API.ashx"        
+    
+    def process(self, pyfile): 
+        if not self.account:
+            self.logError(_("Please enter your zevera.com account or deactivate this plugin"))
+            self.fail("No zevera.com account provided")
+
+        self.logDebug("zevera.com: Old URL: %s" % pyfile.url)
+        
+        last_size = retries = 0
+        olink = self.pyfile.url #quote(self.pyfile.url.encode('utf_8'))
+        
+        for i in range(100):
+            self.retData = self.account.loadAPIRequest(self.req, cmd = 'download_request', olink = olink)       
+            self.checkAPIErrors(self.retData)
+            
+            if self.retData['FileInfo']['StatusID'] == 100: 
+                break
+            elif self.retData['FileInfo']['StatusID'] == 99:
+                self.fail('Failed to initialize download (99)')              
+            else:               
+                if self.retData['FileInfo']['Progress']['BytesReceived'] <= last_size: 
+                    if retries >= 6:
+                        self.fail('Failed to initialize download (%d)' % self.retData['FileInfo']['StatusID'] )
+                    retries += 1
+                else:               
+                    retries = 0
+                
+                last_size = self.retData['FileInfo']['Progress']['BytesReceived']
+                
+                self.setWait(self.retData['Update_Wait'])
+                self.wait()                
+        
+        pyfile.name = self.retData['FileInfo']['RealFileName']
+        pyfile.size = self.retData['FileInfo']['FileSizeInBytes'] 
+        
+        self.retData = self.account.loadAPIRequest(self.req, cmd = 'download_start', FileID = self.retData['FileInfo']['FileID'])
+        self.checkAPIErrors(self.retData)
+        
+        self.download(self.api_url, get = {
+            'cmd': "open_stream",
+            'login': self.account.loginname,
+            'pass': self.account.password,
+            'FileID': self.retData['FileInfo']['FileID'],
+            'startBytes': 0
+            }
+        )                        
+
+    def checkAPIErrors(self, retData):
+        if not retData: 
+            self.fail('Unknown API response')
+            
+        if retData['ErrorCode']: 
+            self.logError(retData['ErrorCode'], retData['ErrorMessage'])
+            #self.fail('ERROR: ' + retData['ErrorMessage'])
+            
+        if self.pyfile.size / 1024000 > retData['AccountInfo']['AvailableTODAYTrafficForUseInMBytes']:
+            self.logWarning("Not enough data left to download the file")
+    
+    def crazyDecode(self, ustring):       
+        # accepts decoded ie. unicode string - API response is double-quoted, double-utf8-encoded
+        # no idea what the proper order of calling these functions would be :-/
+        return html_unescape(unquote(unquote(ustring.replace('@DELIMITER@','#'))).encode('raw_unicode_escape').decode('utf-8'))
     """
\ No newline at end of file
diff --git a/module/plugins/internal/AbstractExtractor.py b/module/plugins/internal/AbstractExtractor.py
index 2130f910e..3cd635eff 100644
--- a/module/plugins/internal/AbstractExtractor.py
+++ b/module/plugins/internal/AbstractExtractor.py
@@ -13,7 +13,7 @@ class WrongPassword(Exception):
 class AbtractExtractor:
     @staticmethod
     def checkDeps():
-        """ Check if system statisfy dependencies
+        """ Check if system satisfies dependencies
         :return: boolean
         """
         return True
@@ -21,7 +21,7 @@ class AbtractExtractor:
     @staticmethod
     def getTargets(files_ids):
         """ Filter suited targets from list of filename id tuple list
-        :param files_ids: List of filepathes
+        :param files_ids: List of file paths
         :return: List of targets, id tuple list
         """
         raise NotImplementedError
@@ -30,10 +30,10 @@ class AbtractExtractor:
     def __init__(self, m, file, out, fullpath, overwrite, renice):
         """Initialize extractor for specific file
 
-        :param m: ExtractArchive Hook plugin
-        :param file: Absolute filepath
+        :param m: ExtractArchive addon plugin
+        :param file: Absolute file path
         :param out: Absolute path to destination directory
-        :param fullpath: extract to fullpath
+        :param fullpath: Extract to fullpath
         :param overwrite: Overwrite existing archives
         :param renice: Renice value
         """
@@ -52,7 +52,7 @@ class AbtractExtractor:
 
 
     def checkArchive(self):
-        """Check if password if needed. Raise ArchiveError if integrity is
+        """Check if password is needed. Raise ArchiveError if integrity is
         questionable.
 
         :return: boolean
diff --git a/module/plugins/internal/MultiHoster.py b/module/plugins/internal/MultiHoster.py
deleted file mode 100644
index a8961aafc..000000000
--- a/module/plugins/internal/MultiHoster.py
+++ /dev/null
@@ -1,189 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-import re
-
-from module.utils import remove_chars
-from module.plugins.Hook import Hook
-
-class MultiHoster(Hook):
-    """
-    Generic MultiHoster plugin
-    """
-
-    __version__ = "0.19"
-
-    replacements = [("2shared.com", "twoshared.com"), ("4shared.com", "fourshared.com"), ("cloudnator.com", "shragle.com"),
-                    ("ifile.it", "filecloud.io"), ("easy-share.com","crocko.com"), ("freakshare.net","freakshare.com"),
-                    ("hellshare.com", "hellshare.cz"), ("share-rapid.cz","sharerapid.com"), ("sharerapid.cz","sharerapid.com"),
-                    ("ul.to","uploaded.to"), ("uploaded.net","uploaded.to"), ("1fichier.com", "onefichier.com")]
-    ignored = []
-    interval = 24 * 60 * 60 # reload hosters daily
-    
-    def setup(self):
-        self.hosters = []
-        self.supported = []
-        self.new_supported = []
-        
-    def getConfig(self, option, default = ''):
-        """getConfig with default value - sublass may not implements all config options""" 
-        try:
-            return self.getConf(option)
-        except KeyError:
-            return default
-
-    def getHosterCached(self):
-        if not self.hosters:
-
-            try:
-                hosterSet = self.toHosterSet(self.getHoster()) - set(self.ignored)
-            except Exception, e:
-                self.logError("%s" % str(e))
-                return []
-                
-            try: 
-                configMode = self.getConfig('hosterListMode', 'all')
-                if configMode in ("listed", "unlisted"):
-                    configSet = self.toHosterSet(self.getConfig('hosterList', '').replace('|',',').replace(';',',').split(','))
-                    
-                    if configMode == "listed":
-                        hosterSet &= configSet
-                    else:
-                        hosterSet -= configSet
-                                
-            except Exception, e:
-                self.logError("%s" % str(e))
-        
-            self.hosters = list(hosterSet)
-
-        return self.hosters
-        
-    def toHosterSet(self, hosters):
-        hosters = set((str(x).strip().lower() for x in hosters))
-    
-        for rep in self.replacements:
-            if rep[0] in hosters:
-                hosters.remove(rep[0])
-                hosters.add(rep[1])
-        
-        hosters.discard('')      
-        return hosters
-
-    def getHoster(self):
-        """Load list of supported hoster
-
-        :return: List of domain names
-        """
-        raise NotImplementedError
-        
-    def coreReady(self):
-        if self.cb:
-            self.core.scheduler.removeJob(self.cb)
-            
-        self.setConfig("activated", True) # config not in sync after plugin reload
-        
-        cfg_interval = self.getConfig("interval", None) # reload interval in hours
-        if cfg_interval is not None:
-            self.interval = cfg_interval * 60 * 60            
-                
-        if self.interval:
-            self._periodical()
-        else:
-            self.periodical()
-            
-    def initPeriodical(self):
-        pass       
-        
-    def periodical(self):
-        """reload hoster list periodically"""
-        self.logInfo("Reloading supported hoster list")
-        
-        old_supported = self.supported
-        self.supported, self.new_supported, self.hosters = [], [], []
-        
-        self.overridePlugins()
-        
-        old_supported = [hoster for hoster in old_supported if hoster not in self.supported]
-        if old_supported:
-            self.logDebug("UNLOAD: %s" % ", ".join(old_supported))
-            for hoster in old_supported:
-                self.unloadHoster(hoster)
-
-    def overridePlugins(self):
-        pluginMap = {}
-        for name in self.core.pluginManager.hosterPlugins.keys():
-            pluginMap[name.lower()] = name
-        
-        accountList = [ name.lower() for name, data in self.core.accountManager.accounts.items() if data ]
-        excludedList = []
-        
-        for hoster in self.getHosterCached():
-            name = remove_chars(hoster.lower(), "-.")
-
-            if name in accountList:
-                excludedList.append(hoster)                
-            else:
-                if name in pluginMap:
-                    self.supported.append(pluginMap[name])
-                else:
-                    self.new_supported.append(hoster)
-
-        if not self.supported and not self.new_supported:
-            self.logError(_("No Hoster loaded"))
-            return
-
-        module = self.core.pluginManager.getPlugin(self.__name__)
-        klass = getattr(module, self.__name__)
-        
-        # inject plugin plugin
-        self.logDebug("Overwritten Hosters: %s" % ", ".join(sorted(self.supported)))
-        for hoster in self.supported:
-            dict = self.core.pluginManager.hosterPlugins[hoster]
-            dict["new_module"] = module
-            dict["new_name"] = self.__name__
-            
-        if excludedList:
-            self.logInfo("The following hosters were not overwritten - account exists: %s" % ", ".join(sorted(excludedList)))
-
-        if self.new_supported:
-            self.logDebug("New Hosters: %s" % ", ".join(sorted(self.new_supported)))
-    
-            # create new regexp
-            regexp = r".*(%s).*" % "|".join([x.replace(".", "\\.") for x in self.new_supported])            
-            if hasattr(klass, "__pattern__") and isinstance(klass.__pattern__, basestring)  and '://' in klass.__pattern__:
-                regexp = r"%s|%s" % (klass.__pattern__, regexp)
-                
-            self.logDebug("Regexp: %s" % regexp)
-    
-            dict = self.core.pluginManager.hosterPlugins[self.__name__]
-            dict["pattern"] = regexp
-            dict["re"] = re.compile(regexp)
-
-    def unloadHoster(self, hoster):
-        dict = self.core.pluginManager.hosterPlugins[hoster]
-        if "module" in dict:
-            del dict["module"]
-
-        if "new_module" in dict:
-            del dict["new_module"]
-            del dict["new_name"]
-
-    def unload(self):
-        """Remove override for all hosters. Scheduler job is removed by hookmanager"""
-        for hoster in self.supported:
-            self.unloadHoster(hoster)
-        
-        # reset pattern
-        klass = getattr(self.core.pluginManager.getPlugin(self.__name__), self.__name__)
-        dict = self.core.pluginManager.hosterPlugins[self.__name__]
-        dict["pattern"] = getattr(klass, '__pattern__', r"^unmatchable$") 
-        dict["re"] = re.compile(dict["pattern"])   
-            
-    def downloadFailed(self, pyfile):
-        """remove plugin override if download fails but not if file is offline/temp.offline"""  
-        if pyfile.hasStatus("failed") and self.getConfig("unloadFailing", True):
-            hdict = self.core.pluginManager.hosterPlugins[pyfile.pluginname]
-            if "new_name" in hdict and hdict['new_name'] == self.__name__:
-                self.logDebug("Unload MultiHoster", pyfile.pluginname, hdict)    
-                self.unloadHoster(pyfile.pluginname)
-                pyfile.setStatus("queued")
\ No newline at end of file
diff --git a/module/plugins/captcha/NetloadIn.py b/module/plugins/internal/NetloadInOCR.py
index 7f2e6a8d1..e50978701 100644
--- a/module/plugins/captcha/NetloadIn.py
+++ b/module/plugins/internal/NetloadInOCR.py
@@ -1,7 +1,10 @@
-from captcha import OCR
+# -*- coding: utf-8 -*-
+
+from OCR import OCR
+
+class NetloadInOCR(OCR):
+    __version__ = 0.1
 
-class NetloadIn(OCR):
-    __name__ = "NetloadIn"
     def __init__(self):
         OCR.__init__(self)
 
@@ -18,7 +21,7 @@ class NetloadIn(OCR):
 
 if __name__ == '__main__':
     import urllib
-    ocr = NetloadIn()
+    ocr = NetloadInOCR()
     urllib.urlretrieve("http://netload.in/share/includes/captcha.php", "captcha.png")
 
     print  ocr.get_captcha('captcha.png')
diff --git a/module/plugins/captcha/captcha.py b/module/plugins/internal/OCR.py
index 4cbb736c1..9f8b7ef8c 100644
--- a/module/plugins/captcha/captcha.py
+++ b/module/plugins/internal/OCR.py
@@ -33,8 +33,7 @@ import JpegImagePlugin
 
 
 class OCR(object):
-    
-    __name__ = "OCR"
+    __version__ = 0.1
     
     def __init__(self):
         self.logger = logging.getLogger("log")
diff --git a/module/plugins/ReCaptcha.py b/module/plugins/internal/ReCaptcha.py
index 6f7ebe22c..6f7ebe22c 100644
--- a/module/plugins/ReCaptcha.py
+++ b/module/plugins/internal/ReCaptcha.py
diff --git a/module/plugins/captcha/ShareonlineBiz.py b/module/plugins/internal/ShareonlineBizOCR.py
index b07fb9b0f..c5c2e92e8 100644
--- a/module/plugins/captcha/ShareonlineBiz.py
+++ b/module/plugins/internal/ShareonlineBizOCR.py
@@ -17,10 +17,10 @@
 # along with this program; if not, see <http://www.gnu.org/licenses/>.
 #
 ###
-from captcha import OCR
+from OCR import OCR
 
-class ShareonlineBiz(OCR):
-    __name__ = "ShareonlineBiz"
+class ShareonlineBizOCR(OCR):
+    __version__ = 0.1
     
     def __init__(self):
         OCR.__init__(self)
@@ -48,6 +48,6 @@ class ShareonlineBiz(OCR):
 
 if __name__ == '__main__':
     import urllib
-    ocr = ShareonlineBiz()
+    ocr = ShareonlineBizOCR()
     urllib.urlretrieve("http://www.share-online.biz/captcha.php", "captcha.jpeg")
     print  ocr.get_captcha('captcha.jpeg')
diff --git a/module/plugins/internal/SimpleHoster.py b/module/plugins/internal/SimpleHoster.py
index cfc9f2b43..666374a22 100644
--- a/module/plugins/internal/SimpleHoster.py
+++ b/module/plugins/internal/SimpleHoster.py
@@ -158,7 +158,7 @@ class SimpleHoster(Hoster):
     or FILE_NAME_INFO = r'(?P<N>file_name)'
     and FILE_SIZE_INFO = r'(?P<S>file_size) (?P<U>units)'
     FILE_OFFLINE_PATTERN = r'File (deleted|not found)'
-    TEMP_OFFLINE_PATTERN = r'Server maintainance'
+    TEMP_OFFLINE_PATTERN = r'Server maintenance'
     """
 
     FILE_SIZE_REPLACEMENTS = []
diff --git a/module/plugins/internal/UnRar.py b/module/plugins/internal/UnRar.py
index 240dc0233..53995a083 100644
--- a/module/plugins/internal/UnRar.py
+++ b/module/plugins/internal/UnRar.py
@@ -19,11 +19,10 @@
 
 import os
 import re
-from os.path import join
 from glob import glob
 from subprocess import Popen, PIPE
 
-from module.utils import save_join, decode
+from module.utils.fs import save_join, decode, fs_encode
 from module.plugins.internal.AbstractExtractor import AbtractExtractor, WrongPassword, ArchiveError, CRCError
 
 class UnRar(AbtractExtractor):
@@ -39,7 +38,7 @@ class UnRar(AbtractExtractor):
     @staticmethod
     def checkDeps():
         if os.name == "nt":
-            UnRar.CMD = join(pypath, "UnRAR.exe")
+            UnRar.CMD = save_join(pypath, "UnRAR.exe")
             p = Popen([UnRar.CMD], stdout=PIPE, stderr=PIPE)
             p.communicate()
         else:
@@ -80,7 +79,7 @@ class UnRar(AbtractExtractor):
         self.password = ""  #save the correct password
 
     def checkArchive(self):
-        p = self.call_unrar("l", "-v", self.file)
+        p = self.call_unrar("l", "-v", fs_encode(self.file))
         out, err = p.communicate()
         if self.re_wrongpwd.search(err):
             self.passwordProtected = True
@@ -102,7 +101,7 @@ class UnRar(AbtractExtractor):
     def checkPassword(self, password):
         #at this point we can only verify header protected files
         if self.headerProtected:
-            p = self.call_unrar("l", "-v", self.file, password=password)
+            p = self.call_unrar("l", "-v", fs_encode(self.file), password=password)
             out, err = p.communicate()
             if self.re_wrongpwd.search(err):
                 return False
@@ -115,7 +114,7 @@ class UnRar(AbtractExtractor):
 
         # popen thinks process is still alive (just like pexpect) - very strange behavior
         # so for now progress can not be determined correctly
-        p = self.call_unrar(command, self.file, self.out, password=password)
+        p = self.call_unrar(command, fs_encode(self.file), self.out, password=password)
         renice(p.pid, self.renice)
 
         progress(0)
@@ -143,7 +142,7 @@ class UnRar(AbtractExtractor):
 
     def listContent(self):
         command = "vb" if self.fullpath else "lb"
-        p = self.call_unrar(command, "-v", self.file, password=self.password)
+        p = self.call_unrar(command, "-v", fs_encode(self.file), password=self.password)
         out, err = p.communicate()
 
         if "Cannot open" in err:
@@ -178,7 +177,7 @@ class UnRar(AbtractExtractor):
 
         #NOTE: return codes are not reliable, some kind of threading, cleanup whatever issue
         call = [self.CMD, command] + args + list(xargs)
-        self.m.logDebug(" ".join(call))
+        self.m.logDebug(" ".join([decode(arg) for arg in call]))
 
         p = Popen(call, stdout=PIPE, stderr=PIPE)
 
diff --git a/module/remote/JSONClient.py b/module/remote/JSONClient.py
new file mode 100644
index 000000000..a2c07a132
--- /dev/null
+++ b/module/remote/JSONClient.py
@@ -0,0 +1,56 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from urllib import urlopen, urlencode
+from httplib import UNAUTHORIZED, FORBIDDEN
+
+from json_converter import loads, dumps
+from apitypes import Unauthorized, Forbidden
+
+class JSONClient:
+    URL = "http://localhost:8001/api"
+
+    def __init__(self, url=None):
+        self.url = url or self.URL
+        self.session = None
+
+    def request(self, path, data):
+        ret = urlopen(self.url + path, urlencode(data))
+        if ret.code == 400:
+            raise loads(ret.read())
+        if ret.code == 404:
+            raise AttributeError("Unknown Method")
+        if ret.code == 500:
+            raise Exception("Remote Exception")
+        if ret.code == UNAUTHORIZED:
+            raise Unauthorized()
+        if ret.code == FORBIDDEN:
+            raise Forbidden()
+        return ret.read()
+
+    def login(self, username, password):
+        self.session = loads(self.request("/login", {'username': username, 'password': password}))
+        return self.session
+
+    def logout(self):
+        self.call("logout")
+        self.session = None
+
+    def call(self, func, *args, **kwargs):
+        # Add the current session
+        kwargs["session"] = self.session
+        path = "/" + func + "/" + "/".join(dumps(x) for x in args)
+        data = dict((k, dumps(v)) for k, v in kwargs.iteritems())
+        rep = self.request(path, data)
+        return loads(rep)
+
+    def __getattr__(self, item):
+        def call(*args, **kwargs):
+            return self.call(item, *args, **kwargs)
+
+        return call
+
+if __name__ == "__main__":
+    api = JSONClient()
+    api.login("User", "test")
+    print api.getServerVersion()
\ No newline at end of file
diff --git a/module/remote/RemoteManager.py b/module/remote/RemoteManager.py
index 36eb52a4a..dd567653b 100644
--- a/module/remote/RemoteManager.py
+++ b/module/remote/RemoteManager.py
@@ -63,9 +63,7 @@ class RemoteManager():
         self.backends = []
 
         if self.core.remote:
-            self.available.append("ThriftBackend")
-#        else:
-#            self.available.append("SocketBackend")
+            self.available.append("WebSocketBackend")
 
 
     def startBackends(self):
diff --git a/module/remote/SocketBackend.py b/module/remote/SocketBackend.py
deleted file mode 100644
index 1a157cf1d..000000000
--- a/module/remote/SocketBackend.py
+++ /dev/null
@@ -1,25 +0,0 @@
-# -*- coding: utf-8 -*-
-
-import SocketServer
-
-from RemoteManager import BackendBase
-
-class RequestHandler(SocketServer.BaseRequestHandler):
-
-    def setup(self):
-        pass
-
-    def handle(self):
-
-        print self.request.recv(1024)
-
-
-
-class SocketBackend(BackendBase):
-
-    def setup(self, host, port):
-        #local only
-        self.server = SocketServer.ThreadingTCPServer(("localhost", port), RequestHandler)
-
-    def serve(self):
-        self.server.serve_forever()
diff --git a/module/remote/ThriftBackend.py b/module/remote/ThriftBackend.py
deleted file mode 100644
index b4a2bb25e..000000000
--- a/module/remote/ThriftBackend.py
+++ /dev/null
@@ -1,56 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    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/>.
-
-    @author: mkaay, RaNaN
-"""
-from os.path import exists
-
-from module.remote.RemoteManager import BackendBase
-
-from thriftbackend.Processor import Processor
-from thriftbackend.Protocol import ProtocolFactory
-from thriftbackend.Socket import ServerSocket
-from thriftbackend.Transport import TransportFactory
-#from thriftbackend.Transport import TransportFactoryCompressed
-
-from thrift.server import TServer
-
-class ThriftBackend(BackendBase):
-    def setup(self, host, port):
-        processor = Processor(self.core.api)
-
-        key = None
-        cert = None
-
-        if self.core.config['ssl']['activated']:
-            if exists(self.core.config['ssl']['cert']) and exists(self.core.config['ssl']['key']):
-                self.core.log.info(_("Using SSL ThriftBackend"))
-                key = self.core.config['ssl']['key']
-                cert = self.core.config['ssl']['cert']
-
-        transport = ServerSocket(port, host, key, cert)
-
-
-#        tfactory = TransportFactoryCompressed()
-        tfactory = TransportFactory()
-        pfactory = ProtocolFactory()
-        
-        self.server = TServer.TThreadedServer(processor, transport, tfactory, pfactory)
-        #self.server = TNonblockingServer.TNonblockingServer(processor, transport, tfactory, pfactory)
-        
-        #server = TServer.TThreadPoolServer(processor, transport, tfactory, pfactory)
-    
-    def serve(self):
-        self.server.serve()
diff --git a/module/remote/WSClient.py b/module/remote/WSClient.py
new file mode 100644
index 000000000..793a6ef28
--- /dev/null
+++ b/module/remote/WSClient.py
@@ -0,0 +1,59 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from websocket import create_connection
+from httplib import UNAUTHORIZED, FORBIDDEN
+
+from json_converter import loads, dumps
+from apitypes import Unauthorized, Forbidden
+
+class WSClient:
+    URL = "ws://localhost:7227/api"
+
+    def __init__(self, url=None):
+        self.url = url or self.URL
+        self.ws =  None
+
+    def connect(self):
+        self.ws = create_connection(self.URL)
+
+    def close(self):
+        self.ws.close()
+
+    def login(self, username, password):
+        if not self.ws: self.connect()
+        return self.call("login", username, password)
+
+    def call(self, func, *args, **kwargs):
+        if not self.ws:
+            raise Exception("Not Connected")
+
+        if kwargs:
+            self.ws.send(dumps([func, args, kwargs]))
+        else: # omit kwargs
+            self.ws.send(dumps([func, args]))
+
+        code, result = loads(self.ws.recv())
+        if code == 400:
+            raise result
+        if code == 404:
+            raise AttributeError("Unknown Method")
+        elif code == 500:
+            raise Exception("Remote Exception: %s" % result)
+        elif code == UNAUTHORIZED:
+            raise Unauthorized()
+        elif code == FORBIDDEN:
+            raise Forbidden()
+
+        return result
+
+    def __getattr__(self, item):
+        def call(*args, **kwargs):
+            return self.call(item, *args, **kwargs)
+
+        return call
+
+if __name__ == "__main__":
+    api = WSClient()
+    api.login("User", "test")
+    print api.getServerVersion()
\ No newline at end of file
diff --git a/module/remote/WebSocketBackend.py b/module/remote/WebSocketBackend.py
new file mode 100644
index 000000000..2d22664c6
--- /dev/null
+++ b/module/remote/WebSocketBackend.py
@@ -0,0 +1,49 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+###############################################################################
+#   Copyright(c) 2008-2012 pyLoad Team
+#   http://www.pyload.org
+#
+#   This file is part of pyLoad.
+#   pyLoad is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU Affero General Public License as
+#   published by the Free Software Foundation, either version 3 of the
+#   License, or (at your option) any later version.
+#
+#   Subjected to the terms and conditions in LICENSE
+#
+#   @author: RaNaN
+###############################################################################
+
+import logging
+
+from module.remote.RemoteManager import BackendBase
+
+from mod_pywebsocket import util
+def get_class_logger(o=None):
+    return logging.getLogger('log')
+
+# Monkey patch for our logger
+util.get_class_logger = get_class_logger
+
+class WebSocketBackend(BackendBase):
+    def setup(self, host, port):
+
+        from wsbackend.Server import WebSocketServer, DefaultOptions
+        from wsbackend.Dispatcher import Dispatcher
+        from wsbackend.ApiHandler import ApiHandler
+        from wsbackend.AsyncHandler import AsyncHandler
+
+        options = DefaultOptions()
+        options.server_host = host
+        options.port = port
+        options.dispatcher = Dispatcher()
+        options.dispatcher.addHandler(ApiHandler.PATH, ApiHandler(self.core.api))
+        options.dispatcher.addHandler(AsyncHandler.PATH, AsyncHandler(self.core.api))
+
+        self.server = WebSocketServer(options)
+
+
+    def serve(self):
+        self.server.serve_forever()
diff --git a/module/remote/__init__.py b/module/remote/__init__.py
index 9298f5337..e69de29bb 100644
--- a/module/remote/__init__.py
+++ b/module/remote/__init__.py
@@ -1,2 +0,0 @@
-# -*- coding: utf-8 -*-
-activated = True
diff --git a/module/remote/apitypes.py b/module/remote/apitypes.py
new file mode 100644
index 000000000..83eb19450
--- /dev/null
+++ b/module/remote/apitypes.py
@@ -0,0 +1,539 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Autogenerated by pyload
+# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+
+class BaseObject(object):
+	__slots__ = []
+
+	def __str__(self):
+		return "<%s %s>" % (self.__class__.__name__, ", ".join("%s=%s" % (k,getattr(self,k)) for k in self.__slots__))
+
+class ExceptionObject(Exception):
+	__slots__ = []
+
+class DownloadState:
+	All = 0
+	Finished = 1
+	Unfinished = 2
+	Failed = 3
+	Unmanaged = 4
+
+class DownloadStatus:
+	NA = 0
+	Offline = 1
+	Online = 2
+	Queued = 3
+	Paused = 4
+	Finished = 5
+	Skipped = 6
+	Failed = 7
+	Starting = 8
+	Waiting = 9
+	Downloading = 10
+	TempOffline = 11
+	Aborted = 12
+	Decrypting = 13
+	Processing = 14
+	Custom = 15
+	Unknown = 16
+
+class FileStatus:
+	Ok = 0
+	Missing = 1
+	Remote = 2
+
+class InputType:
+	NA = 0
+	Text = 1
+	Int = 2
+	File = 3
+	Folder = 4
+	Textbox = 5
+	Password = 6
+	Bool = 7
+	Click = 8
+	Select = 9
+	Multiple = 10
+	List = 11
+	Table = 12
+
+class Interaction:
+	All = 0
+	Notification = 1
+	Captcha = 2
+	Query = 4
+
+class MediaType:
+	All = 0
+	Other = 1
+	Audio = 2
+	Image = 4
+	Video = 8
+	Document = 16
+	Archive = 32
+
+class PackageStatus:
+	Ok = 0
+	Paused = 1
+	Folder = 2
+	Remote = 3
+
+class Permission:
+	All = 0
+	Add = 1
+	Delete = 2
+	Modify = 4
+	Download = 8
+	Accounts = 16
+	Interaction = 32
+	Plugins = 64
+
+class Role:
+	Admin = 0
+	User = 1
+
+class AccountInfo(BaseObject):
+	__slots__ = ['plugin', 'loginname', 'owner', 'valid', 'validuntil', 'trafficleft', 'maxtraffic', 'premium', 'activated', 'shared', 'options']
+
+	def __init__(self, plugin=None, loginname=None, owner=None, valid=None, validuntil=None, trafficleft=None, maxtraffic=None, premium=None, activated=None, shared=None, options=None):
+		self.plugin = plugin
+		self.loginname = loginname
+		self.owner = owner
+		self.valid = valid
+		self.validuntil = validuntil
+		self.trafficleft = trafficleft
+		self.maxtraffic = maxtraffic
+		self.premium = premium
+		self.activated = activated
+		self.shared = shared
+		self.options = options
+
+class AddonInfo(BaseObject):
+	__slots__ = ['func_name', 'description', 'value']
+
+	def __init__(self, func_name=None, description=None, value=None):
+		self.func_name = func_name
+		self.description = description
+		self.value = value
+
+class AddonService(BaseObject):
+	__slots__ = ['func_name', 'description', 'arguments', 'media']
+
+	def __init__(self, func_name=None, description=None, arguments=None, media=None):
+		self.func_name = func_name
+		self.description = description
+		self.arguments = arguments
+		self.media = media
+
+class ConfigHolder(BaseObject):
+	__slots__ = ['name', 'label', 'description', 'long_description', 'items', 'info', 'handler']
+
+	def __init__(self, name=None, label=None, description=None, long_description=None, items=None, info=None, handler=None):
+		self.name = name
+		self.label = label
+		self.description = description
+		self.long_description = long_description
+		self.items = items
+		self.info = info
+		self.handler = handler
+
+class ConfigInfo(BaseObject):
+	__slots__ = ['name', 'label', 'description', 'category', 'user_context', 'activated']
+
+	def __init__(self, name=None, label=None, description=None, category=None, user_context=None, activated=None):
+		self.name = name
+		self.label = label
+		self.description = description
+		self.category = category
+		self.user_context = user_context
+		self.activated = activated
+
+class ConfigItem(BaseObject):
+	__slots__ = ['name', 'label', 'description', 'input', 'default_value', 'value']
+
+	def __init__(self, name=None, label=None, description=None, input=None, default_value=None, value=None):
+		self.name = name
+		self.label = label
+		self.description = description
+		self.input = input
+		self.default_value = default_value
+		self.value = value
+
+class DownloadInfo(BaseObject):
+	__slots__ = ['url', 'plugin', 'hash', 'status', 'statusmsg', 'error']
+
+	def __init__(self, url=None, plugin=None, hash=None, status=None, statusmsg=None, error=None):
+		self.url = url
+		self.plugin = plugin
+		self.hash = hash
+		self.status = status
+		self.statusmsg = statusmsg
+		self.error = error
+
+class DownloadProgress(BaseObject):
+	__slots__ = ['fid', 'pid', 'speed', 'status']
+
+	def __init__(self, fid=None, pid=None, speed=None, status=None):
+		self.fid = fid
+		self.pid = pid
+		self.speed = speed
+		self.status = status
+
+class EventInfo(BaseObject):
+	__slots__ = ['eventname', 'event_args']
+
+	def __init__(self, eventname=None, event_args=None):
+		self.eventname = eventname
+		self.event_args = event_args
+
+class FileDoesNotExists(ExceptionObject):
+	__slots__ = ['fid']
+
+	def __init__(self, fid=None):
+		self.fid = fid
+
+class FileInfo(BaseObject):
+	__slots__ = ['fid', 'name', 'package', 'owner', 'size', 'status', 'media', 'added', 'fileorder', 'download']
+
+	def __init__(self, fid=None, name=None, package=None, owner=None, size=None, status=None, media=None, added=None, fileorder=None, download=None):
+		self.fid = fid
+		self.name = name
+		self.package = package
+		self.owner = owner
+		self.size = size
+		self.status = status
+		self.media = media
+		self.added = added
+		self.fileorder = fileorder
+		self.download = download
+
+class Forbidden(ExceptionObject):
+	pass
+
+class Input(BaseObject):
+	__slots__ = ['type', 'data']
+
+	def __init__(self, type=None, data=None):
+		self.type = type
+		self.data = data
+
+class InteractionTask(BaseObject):
+	__slots__ = ['iid', 'type', 'input', 'default_value', 'title', 'description', 'plugin']
+
+	def __init__(self, iid=None, type=None, input=None, default_value=None, title=None, description=None, plugin=None):
+		self.iid = iid
+		self.type = type
+		self.input = input
+		self.default_value = default_value
+		self.title = title
+		self.description = description
+		self.plugin = plugin
+
+class InvalidConfigSection(ExceptionObject):
+	__slots__ = ['section']
+
+	def __init__(self, section=None):
+		self.section = section
+
+class LinkStatus(BaseObject):
+	__slots__ = ['url', 'name', 'plugin', 'size', 'status', 'packagename']
+
+	def __init__(self, url=None, name=None, plugin=None, size=None, status=None, packagename=None):
+		self.url = url
+		self.name = name
+		self.plugin = plugin
+		self.size = size
+		self.status = status
+		self.packagename = packagename
+
+class OnlineCheck(BaseObject):
+	__slots__ = ['rid', 'data']
+
+	def __init__(self, rid=None, data=None):
+		self.rid = rid
+		self.data = data
+
+class PackageDoesNotExists(ExceptionObject):
+	__slots__ = ['pid']
+
+	def __init__(self, pid=None):
+		self.pid = pid
+
+class PackageInfo(BaseObject):
+	__slots__ = ['pid', 'name', 'folder', 'root', 'owner', 'site', 'comment', 'password', 'added', 'tags', 'status', 'shared', 'packageorder', 'stats', 'fids', 'pids']
+
+	def __init__(self, pid=None, name=None, folder=None, root=None, owner=None, site=None, comment=None, password=None, added=None, tags=None, status=None, shared=None, packageorder=None, stats=None, fids=None, pids=None):
+		self.pid = pid
+		self.name = name
+		self.folder = folder
+		self.root = root
+		self.owner = owner
+		self.site = site
+		self.comment = comment
+		self.password = password
+		self.added = added
+		self.tags = tags
+		self.status = status
+		self.shared = shared
+		self.packageorder = packageorder
+		self.stats = stats
+		self.fids = fids
+		self.pids = pids
+
+class PackageStats(BaseObject):
+	__slots__ = ['linkstotal', 'linksdone', 'sizetotal', 'sizedone']
+
+	def __init__(self, linkstotal=None, linksdone=None, sizetotal=None, sizedone=None):
+		self.linkstotal = linkstotal
+		self.linksdone = linksdone
+		self.sizetotal = sizetotal
+		self.sizedone = sizedone
+
+class ProgressInfo(BaseObject):
+	__slots__ = ['plugin', 'name', 'statusmsg', 'eta', 'done', 'total', 'download']
+
+	def __init__(self, plugin=None, name=None, statusmsg=None, eta=None, done=None, total=None, download=None):
+		self.plugin = plugin
+		self.name = name
+		self.statusmsg = statusmsg
+		self.eta = eta
+		self.done = done
+		self.total = total
+		self.download = download
+
+class ServerStatus(BaseObject):
+	__slots__ = ['speed', 'linkstotal', 'linksqueue', 'sizetotal', 'sizequeue', 'notifications', 'paused', 'download', 'reconnect']
+
+	def __init__(self, speed=None, linkstotal=None, linksqueue=None, sizetotal=None, sizequeue=None, notifications=None, paused=None, download=None, reconnect=None):
+		self.speed = speed
+		self.linkstotal = linkstotal
+		self.linksqueue = linksqueue
+		self.sizetotal = sizetotal
+		self.sizequeue = sizequeue
+		self.notifications = notifications
+		self.paused = paused
+		self.download = download
+		self.reconnect = reconnect
+
+class ServiceDoesNotExists(ExceptionObject):
+	__slots__ = ['plugin', 'func']
+
+	def __init__(self, plugin=None, func=None):
+		self.plugin = plugin
+		self.func = func
+
+class ServiceException(ExceptionObject):
+	__slots__ = ['msg']
+
+	def __init__(self, msg=None):
+		self.msg = msg
+
+class TreeCollection(BaseObject):
+	__slots__ = ['root', 'files', 'packages']
+
+	def __init__(self, root=None, files=None, packages=None):
+		self.root = root
+		self.files = files
+		self.packages = packages
+
+class Unauthorized(ExceptionObject):
+	pass
+
+class UserData(BaseObject):
+	__slots__ = ['uid', 'name', 'email', 'role', 'permission', 'folder', 'traffic', 'dllimit', 'dlquota', 'hddquota', 'user', 'templateName']
+
+	def __init__(self, uid=None, name=None, email=None, role=None, permission=None, folder=None, traffic=None, dllimit=None, dlquota=None, hddquota=None, user=None, templateName=None):
+		self.uid = uid
+		self.name = name
+		self.email = email
+		self.role = role
+		self.permission = permission
+		self.folder = folder
+		self.traffic = traffic
+		self.dllimit = dllimit
+		self.dlquota = dlquota
+		self.hddquota = hddquota
+		self.user = user
+		self.templateName = templateName
+
+class UserDoesNotExists(ExceptionObject):
+	__slots__ = ['user']
+
+	def __init__(self, user=None):
+		self.user = user
+
+class Iface(object):
+	def addFromCollector(self, name, paused):
+		pass
+	def addLinks(self, pid, links):
+		pass
+	def addLocalFile(self, pid, name, path):
+		pass
+	def addPackage(self, name, links, password):
+		pass
+	def addPackageChild(self, name, links, password, root, paused):
+		pass
+	def addPackageP(self, name, links, password, paused):
+		pass
+	def addToCollector(self, links):
+		pass
+	def addUser(self, username, password):
+		pass
+	def callAddon(self, plugin, func, arguments):
+		pass
+	def callAddonHandler(self, plugin, func, pid_or_fid):
+		pass
+	def checkOnlineStatus(self, urls):
+		pass
+	def checkOnlineStatusContainer(self, urls, filename, data):
+		pass
+	def checkURLs(self, urls):
+		pass
+	def configurePlugin(self, plugin):
+		pass
+	def createPackage(self, name, folder, root, password, site, comment, paused):
+		pass
+	def deleteCollLink(self, url):
+		pass
+	def deleteCollPack(self, name):
+		pass
+	def deleteConfig(self, plugin):
+		pass
+	def deleteFiles(self, fids):
+		pass
+	def deletePackages(self, pids):
+		pass
+	def findFiles(self, pattern):
+		pass
+	def findPackages(self, tags):
+		pass
+	def freeSpace(self):
+		pass
+	def generateAndAddPackages(self, links, paused):
+		pass
+	def generateDownloadLink(self, fid, timeout):
+		pass
+	def generatePackages(self, links):
+		pass
+	def getAccountTypes(self):
+		pass
+	def getAccounts(self, refresh):
+		pass
+	def getAddonHandler(self):
+		pass
+	def getAllFiles(self):
+		pass
+	def getAllUserData(self):
+		pass
+	def getAvailablePlugins(self):
+		pass
+	def getCollector(self):
+		pass
+	def getConfig(self):
+		pass
+	def getConfigValue(self, section, option):
+		pass
+	def getCoreConfig(self):
+		pass
+	def getFileInfo(self, fid):
+		pass
+	def getFileTree(self, pid, full):
+		pass
+	def getFilteredFileTree(self, pid, full, state):
+		pass
+	def getFilteredFiles(self, state):
+		pass
+	def getInteractionTasks(self, mode):
+		pass
+	def getLog(self, offset):
+		pass
+	def getPackageContent(self, pid):
+		pass
+	def getPackageInfo(self, pid):
+		pass
+	def getPluginConfig(self):
+		pass
+	def getProgressInfo(self):
+		pass
+	def getServerStatus(self):
+		pass
+	def getServerVersion(self):
+		pass
+	def getUserData(self):
+		pass
+	def getWSAddress(self):
+		pass
+	def hasAddonHandler(self, plugin, func):
+		pass
+	def isInteractionWaiting(self, mode):
+		pass
+	def login(self, username, password):
+		pass
+	def moveFiles(self, fids, pid):
+		pass
+	def movePackage(self, pid, root):
+		pass
+	def orderFiles(self, fids, pid, position):
+		pass
+	def orderPackage(self, pids, position):
+		pass
+	def parseURLs(self, html, url):
+		pass
+	def pauseServer(self):
+		pass
+	def pollResults(self, rid):
+		pass
+	def quit(self):
+		pass
+	def recheckPackage(self, pid):
+		pass
+	def removeAccount(self, plugin, account):
+		pass
+	def removeUser(self, uid):
+		pass
+	def renameCollPack(self, name, new_name):
+		pass
+	def restart(self):
+		pass
+	def restartFailed(self):
+		pass
+	def restartFile(self, fid):
+		pass
+	def restartPackage(self, pid):
+		pass
+	def saveConfig(self, config):
+		pass
+	def searchSuggestions(self, pattern):
+		pass
+	def setConfigHandler(self, plugin, iid, value):
+		pass
+	def setConfigValue(self, section, option, value):
+		pass
+	def setInteractionResult(self, iid, result):
+		pass
+	def setPackageFolder(self, pid, path):
+		pass
+	def setPassword(self, username, old_password, new_password):
+		pass
+	def stopAllDownloads(self):
+		pass
+	def stopDownloads(self, fids):
+		pass
+	def togglePause(self):
+		pass
+	def toggleReconnect(self):
+		pass
+	def unpauseServer(self):
+		pass
+	def updateAccount(self, plugin, account, password):
+		pass
+	def updateAccountInfo(self, account):
+		pass
+	def updatePackage(self, pack):
+		pass
+	def updateUserData(self, data):
+		pass
+	def uploadContainer(self, filename, data):
+		pass
+
diff --git a/module/remote/apitypes_debug.py b/module/remote/apitypes_debug.py
new file mode 100644
index 000000000..6909464d4
--- /dev/null
+++ b/module/remote/apitypes_debug.py
@@ -0,0 +1,136 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Autogenerated by pyload
+# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+
+from ttypes import *
+
+enums = [
+	"DownloadState",
+	"DownloadStatus",
+	"FileStatus",
+	"InputType",
+	"Interaction",
+	"MediaType",
+	"PackageStatus",
+	"Permission",
+	"Role",
+]
+
+classes = {
+	'AccountInfo' : [basestring, basestring, int, bool, int, int, int, bool, bool, bool, (dict, basestring, basestring)],
+	'AddonInfo' : [basestring, basestring, basestring],
+	'AddonService' : [basestring, basestring, (list, basestring), (None, int)],
+	'ConfigHolder' : [basestring, basestring, basestring, basestring, (list, ConfigItem), (None, (list, AddonInfo)), (None, (list, InteractionTask))],
+	'ConfigInfo' : [basestring, basestring, basestring, basestring, bool, (None, bool)],
+	'ConfigItem' : [basestring, basestring, basestring, Input, basestring, basestring],
+	'DownloadInfo' : [basestring, basestring, basestring, int, basestring, basestring],
+	'DownloadProgress' : [int, int, int, int],
+	'EventInfo' : [basestring, (list, basestring)],
+	'FileDoesNotExists' : [int],
+	'FileInfo' : [int, basestring, int, int, int, int, int, int, int, (None, DownloadInfo)],
+	'Input' : [int, (None, basestring)],
+	'InteractionTask' : [int, int, Input, (None, basestring), basestring, basestring, basestring],
+	'InvalidConfigSection' : [basestring],
+	'LinkStatus' : [basestring, basestring, basestring, int, int, basestring],
+	'OnlineCheck' : [int, (None, (dict, basestring, LinkStatus))],
+	'PackageDoesNotExists' : [int],
+	'PackageInfo' : [int, basestring, basestring, int, int, basestring, basestring, basestring, int, (list, basestring), int, bool, int, PackageStats, (list, int), (list, int)],
+	'PackageStats' : [int, int, int, int],
+	'ProgressInfo' : [basestring, basestring, basestring, int, int, int, (None, DownloadProgress)],
+	'ServerStatus' : [int, int, int, int, int, bool, bool, bool, bool],
+	'ServiceDoesNotExists' : [basestring, basestring],
+	'ServiceException' : [basestring],
+	'TreeCollection' : [PackageInfo, (dict, int, FileInfo), (dict, int, PackageInfo)],
+	'UserData' : [int, basestring, basestring, int, int, basestring, int, int, basestring, int, int, basestring],
+	'UserDoesNotExists' : [basestring],
+}
+
+methods = {
+	'addFromCollector': int,
+	'addLinks': None,
+	'addLocalFile': None,
+	'addPackage': int,
+	'addPackageChild': int,
+	'addPackageP': int,
+	'addToCollector': None,
+	'addUser': UserData,
+	'callAddon': None,
+	'callAddonHandler': None,
+	'checkOnlineStatus': OnlineCheck,
+	'checkOnlineStatusContainer': OnlineCheck,
+	'checkURLs': (dict, basestring, list),
+	'configurePlugin': ConfigHolder,
+	'createPackage': int,
+	'deleteCollLink': None,
+	'deleteCollPack': None,
+	'deleteConfig': None,
+	'deleteFiles': None,
+	'deletePackages': None,
+	'findFiles': TreeCollection,
+	'findPackages': TreeCollection,
+	'freeSpace': int,
+	'generateAndAddPackages': (list, int),
+	'generateDownloadLink': basestring,
+	'generatePackages': (dict, basestring, list),
+	'getAccountTypes': (list, basestring),
+	'getAccounts': (list, AccountInfo),
+	'getAddonHandler': (dict, basestring, list),
+	'getAllFiles': TreeCollection,
+	'getAllUserData': (dict, int, UserData),
+	'getAvailablePlugins': (list, ConfigInfo),
+	'getCollector': (list, LinkStatus),
+	'getConfig': (dict, basestring, ConfigHolder),
+	'getConfigValue': basestring,
+	'getCoreConfig': (list, ConfigInfo),
+	'getFileInfo': FileInfo,
+	'getFileTree': TreeCollection,
+	'getFilteredFileTree': TreeCollection,
+	'getFilteredFiles': TreeCollection,
+	'getInteractionTasks': (list, InteractionTask),
+	'getLog': (list, basestring),
+	'getPackageContent': TreeCollection,
+	'getPackageInfo': PackageInfo,
+	'getPluginConfig': (list, ConfigInfo),
+	'getProgressInfo': (list, ProgressInfo),
+	'getServerStatus': ServerStatus,
+	'getServerVersion': basestring,
+	'getUserData': UserData,
+	'getWSAddress': basestring,
+	'hasAddonHandler': bool,
+	'isInteractionWaiting': bool,
+	'login': bool,
+	'moveFiles': bool,
+	'movePackage': bool,
+	'orderFiles': None,
+	'orderPackage': None,
+	'parseURLs': (dict, basestring, list),
+	'pauseServer': None,
+	'pollResults': OnlineCheck,
+	'quit': None,
+	'recheckPackage': None,
+	'removeAccount': None,
+	'removeUser': None,
+	'renameCollPack': None,
+	'restart': None,
+	'restartFailed': None,
+	'restartFile': None,
+	'restartPackage': None,
+	'saveConfig': None,
+	'searchSuggestions': (list, basestring),
+	'setConfigHandler': None,
+	'setConfigValue': None,
+	'setInteractionResult': None,
+	'setPackageFolder': bool,
+	'setPassword': bool,
+	'stopAllDownloads': None,
+	'stopDownloads': None,
+	'togglePause': bool,
+	'toggleReconnect': bool,
+	'unpauseServer': None,
+	'updateAccount': None,
+	'updateAccountInfo': None,
+	'updatePackage': None,
+	'updateUserData': None,
+	'uploadContainer': int,
+}
diff --git a/module/remote/create_apitypes.py b/module/remote/create_apitypes.py
new file mode 100644
index 000000000..7755b5c57
--- /dev/null
+++ b/module/remote/create_apitypes.py
@@ -0,0 +1,181 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import re
+import inspect
+import sys
+from os.path import abspath, dirname, join
+
+path = dirname(abspath(__file__))
+module = join(path, "..", "..")
+
+sys.path.append(join(module, "lib"))
+sys.path.append(join(module, "remote"))
+
+from thrift.Thrift import TType
+from thriftgen.pyload import ttypes
+from thriftgen.pyload import Pyload
+
+type_map = {
+    TType.BOOL: 'bool',
+    TType.DOUBLE: 'float',
+    TType.I16: 'int',
+    TType.I32: 'int',
+    TType.I64: 'int',
+    TType.STRING: 'basestring',
+    TType.MAP: 'dict',
+    TType.LIST: 'list',
+    TType.SET: 'set',
+    TType.VOID: 'None',
+    TType.STRUCT: 'BaseObject',
+    TType.UTF8: 'unicode',
+}
+
+def get_spec(spec, optional=False):
+    """ analyze the generated spec file and writes information into file """
+    if spec[1] == TType.STRUCT:
+        return spec[3][0].__name__
+    elif spec[1]  == TType.LIST:
+        if spec[3][0] == TType.STRUCT:
+            ttype = spec[3][1][0].__name__
+        else:
+            ttype = type_map[spec[3][0]]
+        return "(list, %s)" % ttype
+    elif spec[1] == TType.MAP:
+        if spec[3][2] == TType.STRUCT:
+            ttype = spec[3][3][0].__name__
+        else:
+            ttype = type_map[spec[3][2]]
+
+        return "(dict, %s, %s)" % (type_map[spec[3][0]], ttype)
+    else:
+        return type_map[spec[1]]
+
+optional_re = "%d: +optional +[a-z0-9<>_-]+ +%s"
+
+def main():
+
+    enums = []
+    classes = []
+    tf = open(join(path, "pyload.thrift"), "rb").read()
+
+    print "generating apitypes.py"
+
+    for name in dir(ttypes):
+        klass = getattr(ttypes, name)
+
+        if name in ("TBase", "TExceptionBase") or name.startswith("_") or not (issubclass(klass, ttypes.TBase) or issubclass(klass, ttypes.TExceptionBase)):
+            continue
+
+        if hasattr(klass, "thrift_spec"):
+            classes.append(klass)
+        else:
+            enums.append(klass)
+
+
+    f = open(join(path, "apitypes.py"), "wb")
+    f.write(
+        """#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Autogenerated by pyload
+# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+
+class BaseObject(object):
+\t__slots__ = []
+
+\tdef __str__(self):
+\t\treturn "<%s %s>" % (self.__class__.__name__, ", ".join("%s=%s" % (k,getattr(self,k)) for k in self.__slots__))
+
+class ExceptionObject(Exception):
+\t__slots__ = []
+
+""")
+
+    dev = open(join(path, "apitypes_debug.py"), "wb")
+    dev.write("""#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Autogenerated by pyload
+# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING\n
+from ttypes import *\n
+""")
+
+    dev.write("enums = [\n")
+
+    ## generate enums
+    for enum in enums:
+        name = enum.__name__
+        f.write("class %s:\n" % name)
+
+        for attr in sorted(dir(enum), key=lambda x: getattr(enum, x)):
+            if attr.startswith("_") or attr in ("read", "write"): continue
+            f.write("\t%s = %s\n" % (attr, getattr(enum, attr)))
+
+        dev.write('\t"%s",\n' % name)
+        f.write("\n")
+
+    dev.write("]\n\n")
+
+    dev.write("classes = {\n")
+
+    for klass in classes:
+        name = klass.__name__
+        base = "ExceptionObject" if issubclass(klass, ttypes.TExceptionBase) else "BaseObject"
+        f.write("class %s(%s):\n" % (name,  base))
+
+        # No attributes, don't write further info
+        if not klass.__slots__:
+            f.write("\tpass\n\n")
+            continue
+
+        f.write("\t__slots__ = %s\n\n" % klass.__slots__)
+        dev.write("\t'%s' : [" % name)
+
+        #create init
+        args = ["self"] + ["%s=None" % x for x in klass.__slots__]
+        specs = []
+
+        f.write("\tdef __init__(%s):\n" % ", ".join(args))
+        for i, attr in enumerate(klass.__slots__):
+            f.write("\t\tself.%s = %s\n" % (attr, attr))
+
+            spec = klass.thrift_spec[i+1]
+            # assert correct order, so the list of types is enough for check
+            assert spec[2] == attr
+            # dirty way to check optional attribute, since it is not in the generated code
+            # can produce false positives, but these are not critical
+            optional = re.search(optional_re % (i+1, attr), tf, re.I)
+            if optional:
+                specs.append("(None, %s)" % get_spec(spec))
+            else:
+                specs.append(get_spec(spec))
+
+        f.write("\n")
+        dev.write(", ".join(specs) + "],\n")
+
+    dev.write("}\n\n")
+
+    f.write("class Iface(object):\n")
+    dev.write("methods = {\n")
+
+    for name in dir(Pyload.Iface):
+        if name.startswith("_"): continue
+
+        func = inspect.getargspec(getattr(Pyload.Iface, name))
+
+        f.write("\tdef %s(%s):\n\t\tpass\n" % (name, ", ".join(func.args)))
+
+        spec = getattr(Pyload, "%s_result" % name).thrift_spec
+        if not spec or not spec[0]:
+            dev.write("\t'%s': None,\n" % name)
+        else:
+            spec = spec[0]
+            dev.write("\t'%s': %s,\n" % (name, get_spec(spec)))
+
+    f.write("\n")
+    dev.write("}\n")
+
+    f.close()
+    dev.close()
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/module/remote/create_jstypes.py b/module/remote/create_jstypes.py
new file mode 100644
index 000000000..ad05ec9a8
--- /dev/null
+++ b/module/remote/create_jstypes.py
@@ -0,0 +1,34 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from os.path import abspath, dirname, join
+
+path = dirname(abspath(__file__))
+module = join(path, "..")
+
+import apitypes
+from apitypes_debug import enums
+
+# generate js enums
+def main():
+
+    print "generating apitypes.js"
+
+    f = open(join(module, 'web', 'static', 'js', 'utils', 'apitypes.js'), 'wb')
+    f.write("""// Autogenerated, do not edit!
+define([], function() {
+\treturn {
+""")
+
+    for name in enums:
+        enum = getattr(apitypes, name)
+        values = dict([(attr, getattr(enum, attr)) for attr in dir(enum) if not attr.startswith("_")])
+
+        f.write("\t\t%s: %s,\n" % (name, str(values)))
+
+    f.write("\t};\n});")
+    f.close()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/module/remote/json_converter.py b/module/remote/json_converter.py
new file mode 100644
index 000000000..50f0309bd
--- /dev/null
+++ b/module/remote/json_converter.py
@@ -0,0 +1,64 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+try:
+    from module.common.json_layer import json
+except ImportError:
+    import json
+
+
+import apitypes
+from apitypes import BaseObject
+from apitypes import ExceptionObject
+
+# compact json separator
+separators = (',', ':')
+
+# json encoder that accepts api objects
+class BaseEncoder(json.JSONEncoder):
+
+    def default(self, o):
+        if isinstance(o, BaseObject) or isinstance(o, ExceptionObject):
+            ret = {"@class" : o.__class__.__name__}
+            for att in o.__slots__:
+                ret[att] = getattr(o, att)
+            return ret
+
+        return json.JSONEncoder.default(self, o)
+
+# more compact representation, only clients with information of the classes can handle it
+class BaseEncoderCompact(json.JSONEncoder):
+
+    def default(self, o):
+        if isinstance(o, BaseObject) or isinstance(o, ExceptionObject):
+            ret = {"@compact" : [o.__class__.__name__]}
+            ret["@compact"].extend(getattr(o, attr) for attr in o.__slots__)
+            return ret
+
+        return json.JSONEncoder.default(self, o)
+
+def convert_obj(dct):
+    if '@class' in dct:
+        cls = getattr(apitypes, dct['@class'])
+        del dct['@class']
+        return cls(**dct)
+    elif '@compact' in dct:
+        cls = getattr(apitypes, dct['@compact'][0])
+        return cls(*dct['@compact'][1:])
+
+    return dct
+
+def dumps(*args, **kwargs):
+    if 'compact' in kwargs:
+        kwargs['cls'] = BaseEncoderCompact
+        del kwargs['compact']
+    else:
+        kwargs['cls'] = BaseEncoder
+
+    kwargs['separators'] = separators
+    return json.dumps(*args, **kwargs)
+
+
+def loads(*args, **kwargs):
+    kwargs['object_hook'] = convert_obj
+    return json.loads(*args, **kwargs)
\ No newline at end of file
diff --git a/module/remote/pyload.thrift b/module/remote/pyload.thrift
new file mode 100644
index 000000000..76e755de0
--- /dev/null
+++ b/module/remote/pyload.thrift
@@ -0,0 +1,540 @@
+namespace java org.pyload.thrift
+
+typedef i32 FileID
+typedef i32 PackageID
+typedef i32 ResultID
+typedef i32 InteractionID
+typedef i32 UserID
+typedef i64 UTCDate
+typedef i64 ByteCount
+typedef list<string> LinkList
+typedef string PluginName
+typedef string JSONString
+
+// NA - Not Available
+enum DownloadStatus {
+  NA,
+  Offline,
+  Online,
+  Queued,
+  Paused,
+  Finished,
+  Skipped,
+  Failed,
+  Starting,
+  Waiting,
+  Downloading,
+  TempOffline,
+  Aborted,
+  Decrypting,
+  Processing,
+  Custom,
+  Unknown
+}
+
+// Download states, combination of several downloadstatuses
+// defined in Api
+enum DownloadState {
+    All,
+    Finished,
+    Unfinished,
+    Failed,
+    Unmanaged // internal state
+}
+
+enum MediaType {
+  All = 0
+  Other = 1,
+  Audio = 2,
+  Image = 4,
+  Video = 8,
+  Document = 16,
+  Archive = 32,
+}
+
+enum FileStatus {
+  Ok,
+  Missing,
+  Remote,   // file is available at remote location
+}
+
+enum PackageStatus {
+  Ok,
+  Paused,
+  Folder,
+  Remote,
+}
+
+// types for user interaction
+// some may only be place holder currently not supported
+// also all input - output combination are not reasonable, see InteractionManager for further info
+// Todo: how about: time, ip, s.o.
+enum InputType {
+  NA,
+  Text,
+  Int,
+  File,
+  Folder,
+  Textbox,
+  Password,
+  Bool,   // confirm like, yes or no dialog
+  Click,  // for positional captchas
+  Select,  // select from list
+  Multiple,  // multiple choice from list of elements
+  List, // arbitary list of elements
+  Table  // table like data structure
+}
+// more can be implemented by need
+
+// this describes the type of the outgoing interaction
+// ensure they can be logcial or'ed
+enum Interaction {
+  All = 0,
+  Notification = 1,
+  Captcha = 2,
+  Query = 4,
+}
+
+enum Permission {
+    All = 0,  // requires no permission, but login
+    Add = 1,  // can add packages
+    Delete = 2, // can delete packages
+    Modify = 4, // modify some attribute of downloads
+    Download = 8,  // can download from webinterface
+    Accounts = 16, // can access accounts
+    Interaction = 32, // can interact with plugins
+    Plugins = 64 // user can configure plugins and activate addons
+}
+
+enum Role {
+    Admin = 0,  //admin has all permissions implicit
+    User = 1
+}
+
+struct Input {
+    1: InputType type,
+    2: optional JSONString data,
+}
+
+struct DownloadProgress {
+    1: FileID fid,
+    2: PackageID pid,
+    3: ByteCount speed, // per second
+    4: DownloadStatus status,
+}
+
+struct ProgressInfo {
+  1: PluginName plugin,
+  2: string name,
+  3: string statusmsg,
+  4: i32 eta, // in seconds
+  5: ByteCount done,
+  6: ByteCount total, // arbitary number, size in case of files
+  7: optional DownloadProgress download
+}
+
+// download info for specific file
+struct DownloadInfo {
+  1: string url,
+  2: PluginName plugin,
+  3: string hash,
+  4: DownloadStatus status,
+  5: string statusmsg,
+  6: string error,
+}
+
+struct FileInfo {
+  1: FileID fid,
+  2: string name,
+  3: PackageID package,
+  4: UserID owner,
+  5: ByteCount size,
+  6: FileStatus status,
+  7: MediaType media,
+  8: UTCDate added,
+  9: i16 fileorder,
+  10: optional DownloadInfo download,
+}
+
+struct PackageStats {
+  1: i16 linkstotal,
+  2: i16 linksdone,
+  3: ByteCount sizetotal,
+  4: ByteCount sizedone,
+}
+
+struct PackageInfo {
+  1: PackageID pid,
+  2: string name,
+  3: string folder,
+  4: PackageID root,
+  5: UserID owner,
+  6: string site,
+  7: string comment,
+  8: string password,
+  9: UTCDate added,
+  10: list<string> tags,
+  11: PackageStatus status,
+  12: bool shared,
+  13: i16 packageorder,
+  14: PackageStats stats,
+  15: list<FileID> fids,
+  16: list<PackageID> pids,
+}
+
+// thrift does not allow recursive datatypes, so all data is accumulated and mapped with id
+struct TreeCollection {
+  1: PackageInfo root,
+  2: map<FileID, FileInfo> files,
+  3: map<PackageID, PackageInfo> packages
+}
+
+// general info about link, used for collector and online results
+struct LinkStatus {
+    1: string url,
+    2: string name,
+    3: PluginName plugin,
+    4: ByteCount size,   // size <= 0 : unknown
+    5: DownloadStatus status,
+    6: string packagename,
+}
+
+struct ServerStatus {
+  1: ByteCount speed,
+  2: i16 linkstotal,
+  3: i16 linksqueue,
+  4: ByteCount sizetotal,
+  5: ByteCount sizequeue,
+  6: bool notifications,
+  7: bool paused,
+  8: bool download,
+  9: bool reconnect,
+}
+
+struct InteractionTask {
+  1: InteractionID iid,
+  2: Interaction type,
+  3: Input input,
+  4: optional JSONString default_value,
+  5: string title,
+  6: string description,
+  7: PluginName plugin,
+}
+
+struct AddonService {
+  1: string func_name,
+  2: string description,
+  3: list<string> arguments,
+  4: optional i16 media,
+}
+
+struct AddonInfo {
+  1: string func_name,
+  2: string description,
+  3: JSONString value,
+}
+
+struct ConfigItem {
+  1: string name,
+  2: string label,
+  3: string description,
+  4: Input input,
+  5: JSONString default_value,
+  6: JSONString value,
+}
+
+struct ConfigHolder {
+  1: string name,
+  2: string label,
+  3: string description,
+  4: string long_description,
+  5: list<ConfigItem> items,
+  6: optional list<AddonInfo> info,
+  7: optional list<InteractionTask> handler, // if null plugin is not loaded
+}
+
+struct ConfigInfo {
+  1: string name
+  2: string label,
+  3: string description,
+  4: string category,
+  5: bool user_context,
+  6: optional bool activated,
+}
+
+struct EventInfo {
+  1: string eventname,
+  2: list<JSONString> event_args, //will contain json objects
+}
+
+struct UserData {
+  1: UserID uid,
+  2: string name,
+  3: string email,
+  4: i16 role,
+  5: i16 permission,
+  6: string folder,
+  7: ByteCount traffic
+  8: i16 dllimit
+  9: string dlquota,
+  10: ByteCount hddquota,
+  11: UserID user,
+  12: string templateName
+}
+
+struct AccountInfo {
+  1: PluginName plugin,
+  2: string loginname,
+  3: UserID owner,
+  4: bool valid,
+  5: UTCDate validuntil,
+  6: ByteCount trafficleft,
+  7: ByteCount maxtraffic,
+  8: bool premium,
+  9: bool activated,
+  10: bool shared,
+  11: map<string, string> options,
+}
+
+struct OnlineCheck {
+  1: ResultID rid, // -1 -> nothing more to get
+  2: map<string, LinkStatus> data, // url to result
+}
+
+// exceptions
+
+exception PackageDoesNotExists {
+  1: PackageID pid
+}
+
+exception FileDoesNotExists {
+  1: FileID fid
+}
+
+exception UserDoesNotExists {
+  1: string user
+}
+
+exception ServiceDoesNotExists {
+  1: string plugin
+  2: string func
+}
+
+exception ServiceException {
+  1: string msg
+}
+
+exception InvalidConfigSection {
+  1: string section
+}
+
+exception Unauthorized {
+}
+
+exception Forbidden {
+}
+
+
+service Pyload {
+
+  ///////////////////////
+  // Core Status
+  ///////////////////////
+
+  string getServerVersion(),
+  string getWSAddress(),
+  ServerStatus getServerStatus(),
+  list<ProgressInfo> getProgressInfo(),
+
+  list<string> getLog(1: i32 offset),
+  ByteCount freeSpace(),
+
+  void pauseServer(),
+  void unpauseServer(),
+  bool togglePause(),
+  bool toggleReconnect(),
+
+  void quit(),
+  void restart(),
+
+  ///////////////////////
+  // Configuration
+  ///////////////////////
+
+  map<string, ConfigHolder> getConfig(),
+  string getConfigValue(1: string section, 2: string option),
+
+  // two methods with ambigous classification, could be configuration or addon/plugin related
+  list<ConfigInfo> getCoreConfig(),
+  list<ConfigInfo> getPluginConfig(),
+  list<ConfigInfo> getAvailablePlugins(),
+
+  ConfigHolder configurePlugin(1: PluginName plugin),
+
+  void setConfigValue(1: string section, 2: string option, 3: string value),
+  void saveConfig(1: ConfigHolder config),
+  void deleteConfig(1: PluginName plugin),
+  void setConfigHandler(1: PluginName plugin, 2: InteractionID iid, 3: JSONString value),
+
+  ///////////////////////
+  // Download Preparing
+  ///////////////////////
+
+  map<PluginName, LinkList> checkURLs(1: LinkList urls),
+  map<PluginName, LinkList> parseURLs(1: string html, 2: string url),
+
+  // parses results and generates packages
+  OnlineCheck checkOnlineStatus(1: LinkList urls),
+  OnlineCheck checkOnlineStatusContainer(1: LinkList urls, 2: string filename, 3: binary data)
+
+  // poll results from previously started online check
+  OnlineCheck pollResults(1: ResultID rid),
+
+  // packagename -> urls
+  map<string, LinkList> generatePackages(1: LinkList links),
+
+  ///////////////////////
+  // Download
+  ///////////////////////
+
+  list<PackageID> generateAndAddPackages(1: LinkList links, 2: bool paused),
+
+  PackageID createPackage(1: string name, 2: string folder, 3: PackageID root, 4: string password,
+                            5: string site, 6: string comment, 7: bool paused),
+
+  PackageID addPackage(1: string name, 2: LinkList links, 3: string password),
+  // same as above with paused attribute
+  PackageID addPackageP(1: string name, 2: LinkList links, 3: string password, 4: bool paused),
+
+  // pid -1 is toplevel
+  PackageID addPackageChild(1: string name, 2: LinkList links, 3: string password, 4: PackageID root, 5: bool paused),
+
+  PackageID uploadContainer(1: string filename, 2: binary data),
+
+  void addLinks(1: PackageID pid, 2: LinkList links) throws (1: PackageDoesNotExists e),
+  void addLocalFile(1: PackageID pid, 2: string name, 3: string path) throws (1: PackageDoesNotExists e)
+
+  // these are real file operations and WILL delete files on disk
+  void deleteFiles(1: list<FileID> fids),
+  void deletePackages(1: list<PackageID> pids), // delete the whole folder recursive
+
+  // Modify Downloads
+
+  void restartPackage(1: PackageID pid),
+  void restartFile(1: FileID fid),
+  void recheckPackage(1: PackageID pid),
+  void restartFailed(),
+  void stopDownloads(1: list<FileID> fids),
+  void stopAllDownloads(),
+
+  ///////////////////////
+  // Collector
+  ///////////////////////
+
+  list<LinkStatus> getCollector(),
+
+  void addToCollector(1: LinkList links),
+  PackageID addFromCollector(1: string name, 2: bool paused),
+  void renameCollPack(1: string name, 2: string new_name),
+  void deleteCollPack(1: string name),
+  void deleteCollLink(1: string url),
+
+  ////////////////////////////
+  // File Information retrieval
+  ////////////////////////////
+
+  TreeCollection getAllFiles(),
+  TreeCollection getFilteredFiles(1: DownloadState state),
+
+  // pid -1 for root, full=False only delivers first level in tree
+  TreeCollection getFileTree(1: PackageID pid, 2: bool full),
+  TreeCollection getFilteredFileTree(1: PackageID pid, 2: bool full, 3: DownloadState state),
+
+  // same as above with full=False
+  TreeCollection getPackageContent(1: PackageID pid),
+
+  PackageInfo getPackageInfo(1: PackageID pid) throws (1: PackageDoesNotExists e),
+  FileInfo getFileInfo(1: FileID fid) throws (1: FileDoesNotExists e),
+
+  TreeCollection findFiles(1: string pattern),
+  TreeCollection findPackages(1: list<string> tags),
+  list<string> searchSuggestions(1: string pattern),
+
+  // Modify Files/Packages
+
+  // moving package while downloading is not possible, so they will return bool to indicate success
+  void updatePackage(1: PackageInfo pack) throws (1: PackageDoesNotExists e),
+  bool setPackageFolder(1: PackageID pid, 2: string path) throws (1: PackageDoesNotExists e),
+
+  // as above, this will move files on disk
+  bool movePackage(1: PackageID pid, 2: PackageID root) throws (1: PackageDoesNotExists e),
+  bool moveFiles(1: list<FileID> fids, 2: PackageID pid) throws (1: PackageDoesNotExists e),
+
+  void orderPackage(1: list<PackageID> pids, 2: i16 position),
+  void orderFiles(1: list<FileID> fids, 2: PackageID pid, 3: i16 position),
+
+  ///////////////////////
+  // User Interaction
+  ///////////////////////
+
+  // mode = interaction types binary ORed
+  bool isInteractionWaiting(1: i16 mode),
+  list<InteractionTask> getInteractionTasks(1: i16 mode),
+  void setInteractionResult(1: InteractionID iid, 2: JSONString result),
+
+  // generate a download link, everybody can download the file until timeout reached
+  string generateDownloadLink(1: FileID fid, 2: i16 timeout),
+
+  ///////////////////////
+  // Account Methods
+  ///////////////////////
+
+  list<AccountInfo> getAccounts(1: bool refresh),
+  list<string> getAccountTypes(),
+  void updateAccount(1: PluginName plugin, 2: string account, 3: string password),
+  void updateAccountInfo(1: AccountInfo account),
+  void removeAccount(1: PluginName plugin, 2: string account),
+  
+  /////////////////////////
+  // Auth+User Information
+  /////////////////////////
+
+  bool login(1: string username, 2: string password),
+  // returns own user data
+  UserData getUserData(),
+
+  // all user, for admins only
+  map<UserID, UserData> getAllUserData(),
+
+  UserData addUser(1: string username, 2:string password),
+
+  // normal user can only update their own userdata and not all attributes
+  void updateUserData(1: UserData data),
+  void removeUser(1: UserID uid),
+
+  // works contextual, admin can change every password
+  bool setPassword(1: string username, 2: string old_password, 3: string new_password),
+
+  ///////////////////////
+  // Addon Methods
+  ///////////////////////
+
+  //map<PluginName, list<AddonInfo>> getAllInfo(),
+  //list<AddonInfo> getInfoByPlugin(1: PluginName plugin),
+
+  map<PluginName, list<AddonService>> getAddonHandler(),
+  bool hasAddonHandler(1: PluginName plugin, 2: string func),
+
+  void callAddon(1: PluginName plugin, 2: string func, 3: list<JSONString> arguments)
+        throws (1: ServiceDoesNotExists e, 2: ServiceException ex),
+
+  // special variant of callAddon that works on the media types, acccepting integer
+  void callAddonHandler(1: PluginName plugin, 2: string func, 3: PackageID pid_or_fid)
+        throws (1: ServiceDoesNotExists e, 2: ServiceException ex),
+
+
+  //scheduler
+
+  // TODO
+
+}
diff --git a/module/remote/socketbackend/create_ttypes.py b/module/remote/socketbackend/create_ttypes.py
deleted file mode 100644
index 05662cb50..000000000
--- a/module/remote/socketbackend/create_ttypes.py
+++ /dev/null
@@ -1,91 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-import inspect
-import sys
-from os.path import abspath, dirname, join
-
-path = dirname(abspath(__file__))
-module = join(path, "..", "..")
-
-sys.path.append(join(module, "lib"))
-sys.path.append(join(module, "remote"))
-
-from thriftbackend.thriftgen.pyload import ttypes
-from thriftbackend.thriftgen.pyload.Pyload import Iface
-
-
-def main():
-
-    enums = []
-    classes = []
-
-    print "generating lightweight ttypes.py"
-
-    for name in dir(ttypes):
-        klass = getattr(ttypes, name)
-
-        if name in ("TBase", "TExceptionBase") or name.startswith("_") or not (issubclass(klass, ttypes.TBase) or issubclass(klass, ttypes.TExceptionBase)):
-            continue
-
-        if hasattr(klass, "thrift_spec"):
-           classes.append(klass)
-        else:
-            enums.append(klass)
-
-
-    f = open(join(path, "ttypes.py"), "wb")
-
-    f.write(
-        """#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-# Autogenerated by pyload
-# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
-
-class BaseObject(object):
-\t__slots__ = []
-
-""")
-
-    ## generate enums
-    for enum in enums:
-        name = enum.__name__
-        f.write("class %s:\n" % name)
-
-        for attr in dir(enum):
-            if attr.startswith("_") or attr in ("read", "write"): continue
-
-            f.write("\t%s = %s\n" % (attr, getattr(enum, attr)))
-
-        f.write("\n")
-
-    for klass in classes:
-        name = klass.__name__
-        base = "Exception" if issubclass(klass, ttypes.TExceptionBase) else "BaseObject"
-        f.write("class %s(%s):\n" % (name,  base))
-        f.write("\t__slots__ = %s\n\n" % klass.__slots__)
-
-        #create init
-        args = ["self"] + ["%s=None" % x for x in klass.__slots__]
-
-        f.write("\tdef __init__(%s):\n" % ", ".join(args))
-        for attr in klass.__slots__:
-            f.write("\t\tself.%s = %s\n" % (attr, attr))
-
-        f.write("\n")
-
-    f.write("class Iface:\n")
-
-    for name in dir(Iface):
-        if name.startswith("_"): continue
-
-        func = inspect.getargspec(getattr(Iface, name))
-
-        f.write("\tdef %s(%s):\n\t\tpass\n" % (name, ", ".join(func.args)))
-
-    f.write("\n")
-
-    f.close()
-
-if __name__ == "__main__":
-    main()
\ No newline at end of file
diff --git a/module/remote/socketbackend/ttypes.py b/module/remote/socketbackend/ttypes.py
deleted file mode 100644
index f8ea121fa..000000000
--- a/module/remote/socketbackend/ttypes.py
+++ /dev/null
@@ -1,383 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-# Autogenerated by pyload
-# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
-
-class BaseObject(object):
-	__slots__ = []
-
-class Destination:
-	Collector = 0
-	Queue = 1
-
-class DownloadStatus:
-	Aborted = 9
-	Custom = 11
-	Decrypting = 10
-	Downloading = 12
-	Failed = 8
-	Finished = 0
-	Offline = 1
-	Online = 2
-	Processing = 13
-	Queued = 3
-	Skipped = 4
-	Starting = 7
-	TempOffline = 6
-	Unknown = 14
-	Waiting = 5
-
-class ElementType:
-	File = 1
-	Package = 0
-
-class Input:
-	BOOL = 4
-	CHOICE = 6
-	CLICK = 5
-	LIST = 8
-	MULTIPLE = 7
-	NONE = 0
-	PASSWORD = 3
-	TABLE = 9
-	TEXT = 1
-	TEXTBOX = 2
-
-class Output:
-	CAPTCHA = 1
-	NOTIFICATION = 4
-	QUESTION = 2
-
-class AccountInfo(BaseObject):
-	__slots__ = ['validuntil', 'login', 'options', 'valid', 'trafficleft', 'maxtraffic', 'premium', 'type']
-
-	def __init__(self, validuntil=None, login=None, options=None, valid=None, trafficleft=None, maxtraffic=None, premium=None, type=None):
-		self.validuntil = validuntil
-		self.login = login
-		self.options = options
-		self.valid = valid
-		self.trafficleft = trafficleft
-		self.maxtraffic = maxtraffic
-		self.premium = premium
-		self.type = type
-
-class CaptchaTask(BaseObject):
-	__slots__ = ['tid', 'data', 'type', 'resultType']
-
-	def __init__(self, tid=None, data=None, type=None, resultType=None):
-		self.tid = tid
-		self.data = data
-		self.type = type
-		self.resultType = resultType
-
-class ConfigItem(BaseObject):
-	__slots__ = ['name', 'description', 'value', 'type']
-
-	def __init__(self, name=None, description=None, value=None, type=None):
-		self.name = name
-		self.description = description
-		self.value = value
-		self.type = type
-
-class ConfigSection(BaseObject):
-	__slots__ = ['name', 'description', 'items', 'outline']
-
-	def __init__(self, name=None, description=None, items=None, outline=None):
-		self.name = name
-		self.description = description
-		self.items = items
-		self.outline = outline
-
-class DownloadInfo(BaseObject):
-	__slots__ = ['fid', 'name', 'speed', 'eta', 'format_eta', 'bleft', 'size', 'format_size', 'percent', 'status', 'statusmsg', 'format_wait', 'wait_until', 'packageID', 'packageName', 'plugin']
-
-	def __init__(self, fid=None, name=None, speed=None, eta=None, format_eta=None, bleft=None, size=None, format_size=None, percent=None, status=None, statusmsg=None, format_wait=None, wait_until=None, packageID=None, packageName=None, plugin=None):
-		self.fid = fid
-		self.name = name
-		self.speed = speed
-		self.eta = eta
-		self.format_eta = format_eta
-		self.bleft = bleft
-		self.size = size
-		self.format_size = format_size
-		self.percent = percent
-		self.status = status
-		self.statusmsg = statusmsg
-		self.format_wait = format_wait
-		self.wait_until = wait_until
-		self.packageID = packageID
-		self.packageName = packageName
-		self.plugin = plugin
-
-class EventInfo(BaseObject):
-	__slots__ = ['eventname', 'id', 'type', 'destination']
-
-	def __init__(self, eventname=None, id=None, type=None, destination=None):
-		self.eventname = eventname
-		self.id = id
-		self.type = type
-		self.destination = destination
-
-class FileData(BaseObject):
-	__slots__ = ['fid', 'url', 'name', 'plugin', 'size', 'format_size', 'status', 'statusmsg', 'packageID', 'error', 'order']
-
-	def __init__(self, fid=None, url=None, name=None, plugin=None, size=None, format_size=None, status=None, statusmsg=None, packageID=None, error=None, order=None):
-		self.fid = fid
-		self.url = url
-		self.name = name
-		self.plugin = plugin
-		self.size = size
-		self.format_size = format_size
-		self.status = status
-		self.statusmsg = statusmsg
-		self.packageID = packageID
-		self.error = error
-		self.order = order
-
-class FileDoesNotExists(Exception):
-	__slots__ = ['fid']
-
-	def __init__(self, fid=None):
-		self.fid = fid
-
-class InteractionTask(BaseObject):
-	__slots__ = ['iid', 'input', 'structure', 'preset', 'output', 'data', 'title', 'description', 'plugin']
-
-	def __init__(self, iid=None, input=None, structure=None, preset=None, output=None, data=None, title=None, description=None, plugin=None):
-		self.iid = iid
-		self.input = input
-		self.structure = structure
-		self.preset = preset
-		self.output = output
-		self.data = data
-		self.title = title
-		self.description = description
-		self.plugin = plugin
-
-class OnlineCheck(BaseObject):
-	__slots__ = ['rid', 'data']
-
-	def __init__(self, rid=None, data=None):
-		self.rid = rid
-		self.data = data
-
-class OnlineStatus(BaseObject):
-	__slots__ = ['name', 'plugin', 'packagename', 'status', 'size']
-
-	def __init__(self, name=None, plugin=None, packagename=None, status=None, size=None):
-		self.name = name
-		self.plugin = plugin
-		self.packagename = packagename
-		self.status = status
-		self.size = size
-
-class PackageData(BaseObject):
-	__slots__ = ['pid', 'name', 'folder', 'site', 'password', 'dest', 'order', 'linksdone', 'sizedone', 'sizetotal', 'linkstotal', 'links', 'fids']
-
-	def __init__(self, pid=None, name=None, folder=None, site=None, password=None, dest=None, order=None, linksdone=None, sizedone=None, sizetotal=None, linkstotal=None, links=None, fids=None):
-		self.pid = pid
-		self.name = name
-		self.folder = folder
-		self.site = site
-		self.password = password
-		self.dest = dest
-		self.order = order
-		self.linksdone = linksdone
-		self.sizedone = sizedone
-		self.sizetotal = sizetotal
-		self.linkstotal = linkstotal
-		self.links = links
-		self.fids = fids
-
-class PackageDoesNotExists(Exception):
-	__slots__ = ['pid']
-
-	def __init__(self, pid=None):
-		self.pid = pid
-
-class ServerStatus(BaseObject):
-	__slots__ = ['pause', 'active', 'queue', 'total', 'speed', 'download', 'reconnect']
-
-	def __init__(self, pause=None, active=None, queue=None, total=None, speed=None, download=None, reconnect=None):
-		self.pause = pause
-		self.active = active
-		self.queue = queue
-		self.total = total
-		self.speed = speed
-		self.download = download
-		self.reconnect = reconnect
-
-class ServiceCall(BaseObject):
-	__slots__ = ['plugin', 'func', 'arguments', 'parseArguments']
-
-	def __init__(self, plugin=None, func=None, arguments=None, parseArguments=None):
-		self.plugin = plugin
-		self.func = func
-		self.arguments = arguments
-		self.parseArguments = parseArguments
-
-class ServiceDoesNotExists(Exception):
-	__slots__ = ['plugin', 'func']
-
-	def __init__(self, plugin=None, func=None):
-		self.plugin = plugin
-		self.func = func
-
-class ServiceException(Exception):
-	__slots__ = ['msg']
-
-	def __init__(self, msg=None):
-		self.msg = msg
-
-class UserData(BaseObject):
-	__slots__ = ['name', 'email', 'role', 'permission', 'templateName']
-
-	def __init__(self, name=None, email=None, role=None, permission=None, templateName=None):
-		self.name = name
-		self.email = email
-		self.role = role
-		self.permission = permission
-		self.templateName = templateName
-
-class Iface:
-	def addFiles(self, pid, links):
-		pass
-	def addPackage(self, name, links, dest):
-		pass
-	def call(self, info):
-		pass
-	def checkOnlineStatus(self, urls):
-		pass
-	def checkOnlineStatusContainer(self, urls, filename, data):
-		pass
-	def checkURLs(self, urls):
-		pass
-	def deleteFiles(self, fids):
-		pass
-	def deleteFinished(self):
-		pass
-	def deletePackages(self, pids):
-		pass
-	def freeSpace(self):
-		pass
-	def generateAndAddPackages(self, links, dest):
-		pass
-	def generatePackages(self, links):
-		pass
-	def getAccountTypes(self):
-		pass
-	def getAccounts(self, refresh):
-		pass
-	def getAllInfo(self):
-		pass
-	def getAllUserData(self):
-		pass
-	def getCaptchaTask(self, exclusive):
-		pass
-	def getCaptchaTaskStatus(self, tid):
-		pass
-	def getCollector(self):
-		pass
-	def getCollectorData(self):
-		pass
-	def getConfig(self):
-		pass
-	def getConfigValue(self, category, option, section):
-		pass
-	def getEvents(self, uuid):
-		pass
-	def getFileData(self, fid):
-		pass
-	def getFileOrder(self, pid):
-		pass
-	def getInfoByPlugin(self, plugin):
-		pass
-	def getLog(self, offset):
-		pass
-	def getPackageData(self, pid):
-		pass
-	def getPackageInfo(self, pid):
-		pass
-	def getPackageOrder(self, destination):
-		pass
-	def getPluginConfig(self):
-		pass
-	def getQueue(self):
-		pass
-	def getQueueData(self):
-		pass
-	def getServerVersion(self):
-		pass
-	def getServices(self):
-		pass
-	def getUserData(self, username, password):
-		pass
-	def hasService(self, plugin, func):
-		pass
-	def isCaptchaWaiting(self):
-		pass
-	def isTimeDownload(self):
-		pass
-	def isTimeReconnect(self):
-		pass
-	def kill(self):
-		pass
-	def login(self, username, password):
-		pass
-	def moveFiles(self, fids, pid):
-		pass
-	def movePackage(self, destination, pid):
-		pass
-	def orderFile(self, fid, position):
-		pass
-	def orderPackage(self, pid, position):
-		pass
-	def parseURLs(self, html, url):
-		pass
-	def pauseServer(self):
-		pass
-	def pollResults(self, rid):
-		pass
-	def pullFromQueue(self, pid):
-		pass
-	def pushToQueue(self, pid):
-		pass
-	def recheckPackage(self, pid):
-		pass
-	def removeAccount(self, plugin, account):
-		pass
-	def restart(self):
-		pass
-	def restartFailed(self):
-		pass
-	def restartFile(self, fid):
-		pass
-	def restartPackage(self, pid):
-		pass
-	def setCaptchaResult(self, tid, result):
-		pass
-	def setConfigValue(self, category, option, value, section):
-		pass
-	def setPackageData(self, pid, data):
-		pass
-	def setPackageName(self, pid, name):
-		pass
-	def statusDownloads(self):
-		pass
-	def statusServer(self):
-		pass
-	def stopAllDownloads(self):
-		pass
-	def stopDownloads(self, fids):
-		pass
-	def togglePause(self):
-		pass
-	def toggleReconnect(self):
-		pass
-	def unpauseServer(self):
-		pass
-	def updateAccount(self, plugin, account, password, options):
-		pass
-	def uploadContainer(self, filename, data):
-		pass
-
diff --git a/module/remote/thriftbackend/Processor.py b/module/remote/thriftbackend/Processor.py
deleted file mode 100644
index a8b87c82c..000000000
--- a/module/remote/thriftbackend/Processor.py
+++ /dev/null
@@ -1,77 +0,0 @@
-# -*- coding: utf-8 -*-
-
-from thriftgen.pyload import Pyload
-
-class Processor(Pyload.Processor):
-    def __init__(self, *args, **kwargs):
-        Pyload.Processor.__init__(self, *args, **kwargs)
-        self.authenticated = {}
-
-    def process(self, iprot, oprot):
-        trans = oprot.trans
-        if trans not in self.authenticated:
-            self.authenticated[trans] = False
-            oldclose = trans.close
-
-            def wrap():
-                if self in self.authenticated:
-                    del self.authenticated[trans]
-                oldclose()
-
-            trans.close = wrap
-        authenticated = self.authenticated[trans]
-        (name, type, seqid) = iprot.readMessageBegin()
-
-        # unknown method
-        if name not in self._processMap:
-            iprot.skip(Pyload.TType.STRUCT)
-            iprot.readMessageEnd()
-            x = Pyload.TApplicationException(Pyload.TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % name)
-            oprot.writeMessageBegin(name, Pyload.TMessageType.EXCEPTION, seqid)
-            x.write(oprot)
-            oprot.writeMessageEnd()
-            oprot.trans.flush()
-            return
-
-        # not logged in
-        elif not authenticated and not name == "login":
-            iprot.skip(Pyload.TType.STRUCT)
-            iprot.readMessageEnd()
-            # 20 - Not logged in (in situ declared error code)
-            x = Pyload.TApplicationException(20, 'Not logged in')
-            oprot.writeMessageBegin(name, Pyload.TMessageType.EXCEPTION, seqid)
-            x.write(oprot)
-            oprot.writeMessageEnd()
-            oprot.trans.flush()
-            return
-
-        elif not authenticated and name == "login":
-            args = Pyload.login_args()
-            args.read(iprot)
-            iprot.readMessageEnd()
-            result = Pyload.login_result()
-            # api login
-            self.authenticated[trans] = self._handler.checkAuth(args.username, args.password, trans.remoteaddr[0])
-
-            result.success = True if self.authenticated[trans] else False
-            oprot.writeMessageBegin("login", Pyload.TMessageType.REPLY, seqid)
-            result.write(oprot)
-            oprot.writeMessageEnd()
-            oprot.trans.flush()
-
-        elif self._handler.isAuthorized(name, authenticated):
-            self._processMap[name](self, seqid, iprot, oprot)
-
-        else:
-            #no permission
-            iprot.skip(Pyload.TType.STRUCT)
-            iprot.readMessageEnd()
-            # 21 - Not authorized
-            x = Pyload.TApplicationException(21, 'Not authorized')
-            oprot.writeMessageBegin(name, Pyload.TMessageType.EXCEPTION, seqid)
-            x.write(oprot)
-            oprot.writeMessageEnd()
-            oprot.trans.flush()
-            return
-
-        return True
diff --git a/module/remote/thriftbackend/Protocol.py b/module/remote/thriftbackend/Protocol.py
deleted file mode 100644
index c42d01459..000000000
--- a/module/remote/thriftbackend/Protocol.py
+++ /dev/null
@@ -1,30 +0,0 @@
-# -*- coding: utf-8 -*-
-
-from thrift.protocol import TBinaryProtocol
-
-class Protocol(TBinaryProtocol.TBinaryProtocol):
-    def writeString(self, str):
-        try:
-            str = str.encode("utf8", "ignore")
-        except Exception, e:
-            pass
-
-        self.writeI32(len(str))
-        self.trans.write(str)
-
-    def readString(self):
-        len = self.readI32()
-        str = self.trans.readAll(len)
-        try:
-            str = str.decode("utf8", "ignore")
-        except:
-            pass
-
-        return str
-
-
-class ProtocolFactory(TBinaryProtocol.TBinaryProtocolFactory):
-
-    def getProtocol(self, trans):
-        prot = Protocol(trans, self.strictRead, self.strictWrite)
-        return prot
\ No newline at end of file
diff --git a/module/remote/thriftbackend/Socket.py b/module/remote/thriftbackend/Socket.py
deleted file mode 100644
index 2243f9df2..000000000
--- a/module/remote/thriftbackend/Socket.py
+++ /dev/null
@@ -1,129 +0,0 @@
-# -*- coding: utf-8 -*-
-
-import sys
-import socket
-import errno
-
-from time import sleep
-
-from thrift.transport.TSocket import TSocket, TServerSocket, TTransportException
-
-WantReadError = Exception #overwritten when ssl is used
-
-class SecureSocketConnection:
-    def __init__(self, connection):
-        self.__dict__["connection"] = connection
-
-    def __getattr__(self, name):
-        return getattr(self.__dict__["connection"], name)
-
-    def __setattr__(self, name, value):
-        setattr(self.__dict__["connection"], name, value)
-
-    def shutdown(self, how=1):
-        self.__dict__["connection"].shutdown()
-
-    def accept(self):
-        connection, address = self.__dict__["connection"].accept()
-        return SecureSocketConnection(connection), address
-    
-    def send(self, buff):
-        try:
-            return self.__dict__["connection"].send(buff)
-        except WantReadError:
-            sleep(0.1)
-            return self.send(buff)
-    
-    def recv(self, buff):
-        try:
-            return self.__dict__["connection"].recv(buff)
-        except WantReadError:
-            sleep(0.1)
-            return self.recv(buff)
-
-class Socket(TSocket):
-    def __init__(self, host='localhost', port=7228, ssl=False):
-        TSocket.__init__(self, host, port)
-        self.ssl = ssl
-
-    def open(self):
-        if self.ssl:
-            SSL = __import__("OpenSSL", globals(), locals(), "SSL", -1).SSL
-            WantReadError = SSL.WantReadError
-            ctx = SSL.Context(SSL.SSLv23_METHOD)
-            c = SSL.Connection(ctx, socket.socket(socket.AF_INET, socket.SOCK_STREAM))
-            c.set_connect_state()
-            self.handle = SecureSocketConnection(c)
-        else:
-            self.handle = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-
-        #errno 104 connection reset
-
-        self.handle.settimeout(self._timeout)
-        self.handle.connect((self.host, self.port))
-
-    def read(self, sz):
-        try:
-            buff = self.handle.recv(sz)
-        except socket.error, e:
-            if (e.args[0] == errno.ECONNRESET and
-                (sys.platform == 'darwin' or sys.platform.startswith('freebsd'))):
-                # freebsd and Mach don't follow POSIX semantic of recv
-                # and fail with ECONNRESET if peer performed shutdown.
-                # See corresponding comment and code in TSocket::read()
-                # in lib/cpp/src/transport/TSocket.cpp.
-                self.close()
-                # Trigger the check to raise the END_OF_FILE exception below.
-                buff = ''
-            else:
-                raise
-        except Exception, e:
-            # SSL connection was closed
-            if e.args == (-1, 'Unexpected EOF'):
-                buff = ''
-            elif e.args == ([('SSL routines', 'SSL23_GET_CLIENT_HELLO', 'unknown protocol')],):
-                #a socket not using ssl tried to connect
-                buff = ''
-            else:
-                raise
-            
-        if not len(buff):
-            raise TTransportException(type=TTransportException.END_OF_FILE, message='TSocket read 0 bytes')
-        return buff
-
-
-class ServerSocket(TServerSocket, Socket):
-    def __init__(self, port=7228, host="0.0.0.0", key="", cert=""):
-        self.host = host
-        self.port = port
-        self.key = key
-        self.cert = cert
-        self.handle = None
-
-    def listen(self):
-        if self.cert and self.key:
-            SSL = __import__("OpenSSL", globals(), locals(), "SSL", -1).SSL
-            WantReadError = SSL.WantReadError
-            ctx = SSL.Context(SSL.SSLv23_METHOD)
-            ctx.use_privatekey_file(self.key)
-            ctx.use_certificate_file(self.cert)
-
-            tmpConnection = SSL.Connection(ctx, socket.socket(socket.AF_INET, socket.SOCK_STREAM))
-            tmpConnection.set_accept_state()
-            self.handle = SecureSocketConnection(tmpConnection)
-
-        else:
-            self.handle = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-
-
-        self.handle.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-        if hasattr(self.handle, 'set_timeout'):
-            self.handle.set_timeout(None)
-        self.handle.bind((self.host, self.port))
-        self.handle.listen(128)
-
-    def accept(self):
-        client, addr = self.handle.accept()
-        result = Socket()
-        result.setHandle(client)
-        return result
diff --git a/module/remote/thriftbackend/ThriftClient.py b/module/remote/thriftbackend/ThriftClient.py
deleted file mode 100644
index 74363cf62..000000000
--- a/module/remote/thriftbackend/ThriftClient.py
+++ /dev/null
@@ -1,109 +0,0 @@
-# -*- coding: utf-8 -*-
-
-import sys
-from socket import error
-from os.path import dirname, abspath, join
-from traceback import print_exc
-
-try:
-    import thrift
-except ImportError:
-    sys.path.append(abspath(join(dirname(abspath(__file__)), "..", "..", "lib")))
-
-from thrift.transport import TTransport
-#from thrift.transport.TZlibTransport import TZlibTransport
-from Socket import Socket
-from Protocol import Protocol
-
-# modules should import ttypes from here, when want to avoid importing API
-
-from thriftgen.pyload import Pyload
-from thriftgen.pyload.ttypes import *
-
-ConnectionClosed = TTransport.TTransportException
-
-class WrongLogin(Exception):
-    pass
-
-class NoConnection(Exception):
-    pass
-
-class NoSSL(Exception):
-    pass
-
-class ThriftClient:
-    def __init__(self, host="localhost", port=7227, user="", password=""):
-
-        self.createConnection(host, port)
-        try:
-            self.transport.open()
-        except error, e:
-            if e.args and e.args[0] in (111, 10061):
-                raise NoConnection
-            else:
-                print_exc()
-                raise NoConnection
-
-        try:
-            correct = self.client.login(user, password)
-        except error, e:
-            if e.args and e.args[0] == 104:
-                #connection reset by peer, probably wants ssl
-                try:
-                    self.createConnection(host, port, True)
-                    #set timeout or a ssl socket will block when querying none ssl server
-                    self.socket.setTimeout(10)
-
-                except ImportError:
-                    #@TODO untested
-                    raise NoSSL
-                try:
-                   self.transport.open()
-                   correct = self.client.login(user, password)
-                finally:
-                    self.socket.setTimeout(None)
-            elif e.args and e.args[0] == 32:
-                raise NoConnection
-            else:
-                print_exc()
-                raise NoConnection
-
-        if not correct:
-            self.transport.close()
-            raise WrongLogin
-
-    def createConnection(self, host, port, ssl=False):
-        self.socket = Socket(host, port, ssl)
-        self.transport = TTransport.TBufferedTransport(self.socket)
-#        self.transport = TZlibTransport(TTransport.TBufferedTransport(self.socket))
-
-        protocol = Protocol(self.transport)
-        self.client = Pyload.Client(protocol)
-
-    def close(self):
-        self.transport.close()
-
-    def __getattr__(self, item):
-        return getattr(self.client, item)
-
-if __name__ == "__main__":
-
-    client = ThriftClient(user="User", password="pwhere")
-
-    print client.getServerVersion()
-    print client.statusServer()
-    print client.statusDownloads()
-    q = client.getQueue()
-
-#    for p in q:
-#      data = client.getPackageData(p.pid)
-#      print data
-#      print "Package Name: ", data.name
-
-
-    print client.getServices()
-    print client.call(Pyload.ServiceCall("UpdateManager", "recheckForUpdates"))
-
-    print client.getConfigValue("download", "limit_speed", "core")
-
-    client.close()
\ No newline at end of file
diff --git a/module/remote/thriftbackend/ThriftTest.py b/module/remote/thriftbackend/ThriftTest.py
deleted file mode 100644
index 69ac6a745..000000000
--- a/module/remote/thriftbackend/ThriftTest.py
+++ /dev/null
@@ -1,92 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-import sys
-from os.path import join,abspath,dirname
-
-path = join((abspath(dirname(__file__))), "..","..", "lib")
-sys.path.append(path)
-
-from thriftgen.pyload import Pyload
-from thriftgen.pyload.ttypes import *
-from Socket import Socket
-
-from thrift import Thrift
-from thrift.transport import TTransport
-
-from Protocol import Protocol
-
-from time import time
-
-import xmlrpclib
-
-def bench(f, *args, **kwargs):
-    s = time()
-    ret = [f(*args, **kwargs) for i in range(0,100)]
-    e = time()
-    try:
-        print "%s: %f s" % (f._Method__name, e-s)
-    except :
-        print "%s: %f s" % (f.__name__, e-s)
-    return ret
-
-from getpass import getpass
-user = raw_input("user ")
-passwd = getpass("password ")
-
-server_url = "http%s://%s:%s@%s:%s/" % (
-  "",
-  user,
-  passwd,
-  "127.0.0.1",
-  7227
-)
-proxy = xmlrpclib.ServerProxy(server_url, allow_none=True)
-
-bench(proxy.get_server_version)
-bench(proxy.status_server)
-bench(proxy.status_downloads)
-#bench(proxy.get_queue)
-#bench(proxy.get_collector)
-print
-try:
-
-    # Make socket
-    transport = Socket('localhost', 7228, False)
-
-    # Buffering is critical. Raw sockets are very slow
-    transport = TTransport.TBufferedTransport(transport)
-
-    # Wrap in a protocol
-    protocol = Protocol(transport)
-
-    # Create a client to use the protocol encoder
-    client = Pyload.Client(protocol)
-
-    # Connect!
-    transport.open()
-
-    print "Login", client.login(user, passwd)
-
-    bench(client.getServerVersion)
-    bench(client.statusServer)
-    bench(client.statusDownloads)
-    #bench(client.getQueue)
-    #bench(client.getCollector)
-
-    print
-    print client.getServerVersion()
-    print client.statusServer()
-    print client.statusDownloads()
-    q = client.getQueue()
-
-    for p in q:
-      data = client.getPackageData(p.pid)
-      print data
-      print "Package Name: ", data.name
-
-    # Close!
-    transport.close()
-
-except Thrift.TException, tx:
-    print 'ThriftExpection: %s' % tx.message
diff --git a/module/remote/thriftbackend/Transport.py b/module/remote/thriftbackend/Transport.py
deleted file mode 100644
index 5772c5a9e..000000000
--- a/module/remote/thriftbackend/Transport.py
+++ /dev/null
@@ -1,37 +0,0 @@
-# -*- coding: utf-8 -*-
-
-from thrift.transport.TTransport import TBufferedTransport
-from thrift.transport.TZlibTransport import TZlibTransport
-
-class Transport(TBufferedTransport):
-    DEFAULT_BUFFER = 4096
-
-    def __init__(self, trans, rbuf_size = DEFAULT_BUFFER):
-        TBufferedTransport.__init__(self, trans, rbuf_size)
-        self.handle = trans.handle
-        self.remoteaddr = trans.handle.getpeername()
-
-class TransportCompressed(TZlibTransport):
-    DEFAULT_BUFFER = 4096
-
-    def __init__(self, trans, rbuf_size = DEFAULT_BUFFER):
-        TZlibTransport.__init__(self, trans, rbuf_size)
-        self.handle = trans.handle
-        self.remoteaddr = trans.handle.getpeername()
-
-class TransportFactory:
-    def getTransport(self, trans):
-        buffered = Transport(trans)
-        return buffered
-
-class TransportFactoryCompressed:
-    _last_trans = None
-    _last_z = None
-
-    def getTransport(self, trans, compresslevel=9):
-        if trans == self._last_trans:
-          return self._last_z
-        ztrans = TransportCompressed(Transport(trans), compresslevel)
-        self._last_trans = trans
-        self._last_z = ztrans
-        return ztrans
\ No newline at end of file
diff --git a/module/remote/thriftbackend/__init__.py b/module/remote/thriftbackend/__init__.py
deleted file mode 100644
index e69de29bb..000000000
--- a/module/remote/thriftbackend/__init__.py
+++ /dev/null
diff --git a/module/remote/thriftbackend/pyload.thrift b/module/remote/thriftbackend/pyload.thrift
deleted file mode 100644
index 1542e651a..000000000
--- a/module/remote/thriftbackend/pyload.thrift
+++ /dev/null
@@ -1,337 +0,0 @@
-namespace java org.pyload.thrift
-
-typedef i32 FileID
-typedef i32 PackageID
-typedef i32 TaskID
-typedef i32 ResultID
-typedef i32 InteractionID
-typedef list<string> LinkList
-typedef string PluginName
-typedef byte Progress
-typedef byte Priority
-
-
-enum DownloadStatus {
-  Finished
-  Offline,
-  Online,
-  Queued,
-  Skipped,
-  Waiting,
-  TempOffline,
-  Starting,
-  Failed,
-  Aborted,
-  Decrypting,
-  Custom,
-  Downloading,
-  Processing,
-  Unknown
-}
-
-enum Destination {
-  Collector,
-  Queue
-}
-
-enum ElementType {
-  Package,
-  File
-}
-
-// types for user interaction
-// some may only be place holder currently not supported
-// also all input - output combination are not reasonable, see InteractionManager for further info
-enum Input {
-  NONE,
-  TEXT,
-  TEXTBOX,
-  PASSWORD,
-  BOOL,   // confirm like, yes or no dialog
-  CLICK,  // for positional captchas
-  CHOICE,  // choice from list
-  MULTIPLE,  // multiple choice from list of elements
-  LIST, // arbitary list of elements
-  TABLE  // table like data structure
-}
-// more can be implemented by need
-
-// this describes the type of the outgoing interaction
-// ensure they can be logcial or'ed
-enum Output {
-  CAPTCHA = 1,
-  QUESTION = 2,
-  NOTIFICATION = 4,
-}
-
-struct DownloadInfo {
-  1: FileID fid,
-  2: string name,
-  3: i64 speed,
-  4: i32 eta,
-  5: string format_eta,
-  6: i64 bleft,
-  7: i64 size,
-  8: string format_size,
-  9: Progress percent,
-  10: DownloadStatus status,
-  11: string statusmsg,
-  12: string format_wait,
-  13: i64 wait_until,
-  14: PackageID packageID,
-  15: string packageName,
-  16: PluginName plugin,
-}
-
-struct ServerStatus {
-  1: bool pause,
-  2: i16 active,
-  3: i16 queue,
-  4: i16 total,
-  5: i64 speed,
-  6: bool download,
-  7: bool reconnect
-}
-
-struct ConfigItem {
-  1: string name,
-  2: string description,
-  3: string value,
-  4: string type,
-}
-
-struct ConfigSection {
-  1: string name,
-  2: string description,
-  3: list<ConfigItem> items,
-  4: optional string outline
-}
-
-struct FileData {
-  1: FileID fid,
-  2: string url,
-  3: string name,
-  4: PluginName plugin,
-  5: i64 size,
-  6: string format_size,
-  7: DownloadStatus status,
-  8: string statusmsg,
-  9: PackageID packageID,
-  10: string error,
-  11: i16 order
-}
-
-struct PackageData {
-  1: PackageID pid,
-  2: string name,
-  3: string folder,
-  4: string site,
-  5: string password,
-  6: Destination dest,
-  7: i16 order,
-  8: optional i16 linksdone,
-  9: optional i64 sizedone,
-  10: optional i64 sizetotal,
-  11: optional i16 linkstotal,
-  12: optional list<FileData> links,
-  13: optional list<FileID> fids
-}
-
-struct InteractionTask {
-  1: InteractionID iid,
-  2: Input input,
-  3: list<string> structure,
-  4: list<string> preset,
-  5: Output output,
-  6: list<string> data,
-  7: string title,
-  8: string description,
-  9: string plugin,
-}
-
-struct CaptchaTask {
-  1: i16 tid,
-  2: binary data,
-  3: string type,
-  4: string resultType
-}
-
-struct EventInfo {
-  1: string eventname,
-  2: optional i32 id,
-  3: optional ElementType type,
-  4: optional Destination destination
-}
-
-struct UserData {
-  1: string name,
-  2: string email,
-  3: i32 role,
-  4: i32 permission,
-  5: string templateName
-}
-
-struct AccountInfo {
-  1: i64 validuntil,
-  2: string login,
-  3: map<string, list<string>> options,
-  4: bool valid,
-  5: i64 trafficleft,
-  6: i64 maxtraffic,
-  7: bool premium,
-  8: string type,
-}
-
-struct ServiceCall {
-    1: PluginName plugin,
-    2: string func,
-    3: optional list<string> arguments,
-    4: optional bool parseArguments,  //default False
-}
-
-struct OnlineStatus {
-    1: string name,
-    2: PluginName plugin,
-    3: string packagename,
-    4: DownloadStatus status,
-    5: i64 size,   // size <= 0 : unknown
-}
-
-struct OnlineCheck {
-    1: ResultID rid, // -1 -> nothing more to get
-    2: map<string, OnlineStatus> data, //url to result
-}
-
-
-// exceptions
-
-exception PackageDoesNotExists{
-  1: PackageID pid
-}
-
-exception FileDoesNotExists{
-  1: FileID fid
-}
-
-exception ServiceDoesNotExists{
-  1: string plugin
-  2: string func
-}
-
-exception ServiceException{
-  1: string msg
-}
-
-service Pyload {
-
-  //config
-  string getConfigValue(1: string category, 2: string option, 3: string section),
-  void setConfigValue(1: string category, 2: string option, 3: string value, 4: string section),
-  map<string, ConfigSection> getConfig(),
-  map<string, ConfigSection> getPluginConfig(),
-
-  // server status
-  void pauseServer(),
-  void unpauseServer(),
-  bool togglePause(),
-  ServerStatus statusServer(),
-  i64 freeSpace(),
-  string getServerVersion(),
-  void kill(),
-  void restart(),
-  list<string> getLog(1: i32 offset),
-  bool isTimeDownload(),
-  bool isTimeReconnect(),
-  bool toggleReconnect(),
-
-  // download preparing
-
-  // packagename - urls
-  map<string, LinkList> generatePackages(1: LinkList links),
-  map<PluginName, LinkList> checkURLs(1: LinkList urls),
-  map<PluginName, LinkList> parseURLs(1: string html, 2: string url),
-
-  // parses results and generates packages
-  OnlineCheck checkOnlineStatus(1: LinkList urls),
-  OnlineCheck checkOnlineStatusContainer(1: LinkList urls, 2: string filename, 3: binary data)
-
-  // poll results from previosly started online check
-  OnlineCheck pollResults(1: ResultID rid),
-
-  // downloads - information
-  list<DownloadInfo> statusDownloads(),
-  PackageData getPackageData(1: PackageID pid) throws (1: PackageDoesNotExists e),
-  PackageData getPackageInfo(1: PackageID pid) throws (1: PackageDoesNotExists e),
-  FileData getFileData(1: FileID fid) throws (1: FileDoesNotExists e),
-  list<PackageData> getQueue(),
-  list<PackageData> getCollector(),
-  list<PackageData> getQueueData(),
-  list<PackageData> getCollectorData(),
-  map<i16, PackageID> getPackageOrder(1: Destination destination),
-  map<i16, FileID> getFileOrder(1: PackageID pid)
-
-  // downloads - adding/deleting
-  list<PackageID> generateAndAddPackages(1: LinkList links, 2: Destination dest),
-  PackageID addPackage(1: string name, 2: LinkList links, 3: Destination dest),
-  void addFiles(1: PackageID pid, 2: LinkList links),
-  void uploadContainer(1: string filename, 2: binary data),
-  void deleteFiles(1: list<FileID> fids),
-  void deletePackages(1: list<PackageID> pids),
-
-  // downloads - modifying
-  void pushToQueue(1: PackageID pid),
-  void pullFromQueue(1: PackageID pid),
-  void restartPackage(1: PackageID pid),
-  void restartFile(1: FileID fid),
-  void recheckPackage(1: PackageID pid),
-  void stopAllDownloads(),
-  void stopDownloads(1: list<FileID> fids),
-  void setPackageName(1: PackageID pid, 2: string name),
-  void movePackage(1: Destination destination, 2: PackageID pid),
-  void moveFiles(1: list<FileID> fids, 2: PackageID pid),
-  void orderPackage(1: PackageID pid, 2: i16 position),
-  void orderFile(1: FileID fid, 2: i16 position),
-  void setPackageData(1: PackageID pid, 2: map<string, string> data) throws (1: PackageDoesNotExists e),
-  list<PackageID> deleteFinished(),
-  void restartFailed(),
-
-  //events
-  list<EventInfo> getEvents(1: string uuid)
-  
-  //accounts
-  list<AccountInfo> getAccounts(1: bool refresh),
-  list<string> getAccountTypes()
-  void updateAccount(1: PluginName plugin, 2: string account, 3: string password, 4: map<string, string> options),
-  void removeAccount(1: PluginName plugin, 2: string account),
-  
-  //auth
-  bool login(1: string username, 2: string password),
-  UserData getUserData(1: string username, 2:string password),
-  map<string, UserData> getAllUserData(),
-
-  //services
-
-  // servicename : description
-  map<PluginName, map<string, string>> getServices(),
-  bool hasService(1: PluginName plugin, 2: string func),
-  string call(1: ServiceCall info) throws (1: ServiceDoesNotExists ex, 2: ServiceException e),
-
-
-  //info
-  // {plugin: {name: value}}
-  map<PluginName, map<string,string>> getAllInfo(),
-  map<string, string> getInfoByPlugin(1: PluginName plugin),
-
-  //scheduler
-
-  // TODO
-
-
-  // User interaction
-
-  //captcha
-  bool isCaptchaWaiting(),
-  CaptchaTask getCaptchaTask(1: bool exclusive),
-  string getCaptchaTaskStatus(1: TaskID tid),
-  void setCaptchaResult(1: TaskID tid, 2: string result),
-}
diff --git a/module/remote/thriftbackend/thriftgen/__init__.py b/module/remote/thriftbackend/thriftgen/__init__.py
deleted file mode 100644
index e69de29bb..000000000
--- a/module/remote/thriftbackend/thriftgen/__init__.py
+++ /dev/null
diff --git a/module/remote/thriftbackend/thriftgen/pyload/Pyload-remote b/module/remote/thriftbackend/thriftgen/pyload/Pyload-remote
deleted file mode 100755
index bfaf5b078..000000000
--- a/module/remote/thriftbackend/thriftgen/pyload/Pyload-remote
+++ /dev/null
@@ -1,571 +0,0 @@
-#!/usr/bin/env python
-#
-# Autogenerated by Thrift Compiler (0.9.0-dev)
-#
-# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
-#
-#  options string: py:slots,dynamic
-#
-
-import sys
-import pprint
-from urlparse import urlparse
-from thrift.transport import TTransport
-from thrift.transport import TSocket
-from thrift.transport import THttpClient
-from thrift.protocol import TBinaryProtocol
-
-import Pyload
-from ttypes import *
-
-if len(sys.argv) <= 1 or sys.argv[1] == '--help':
-  print ''
-  print 'Usage: ' + sys.argv[0] + ' [-h host[:port]] [-u url] [-f[ramed]] function [arg1 [arg2...]]'
-  print ''
-  print 'Functions:'
-  print '  string getConfigValue(string category, string option, string section)'
-  print '  void setConfigValue(string category, string option, string value, string section)'
-  print '   getConfig()'
-  print '   getPluginConfig()'
-  print '  void pauseServer()'
-  print '  void unpauseServer()'
-  print '  bool togglePause()'
-  print '  ServerStatus statusServer()'
-  print '  i64 freeSpace()'
-  print '  string getServerVersion()'
-  print '  void kill()'
-  print '  void restart()'
-  print '   getLog(i32 offset)'
-  print '  bool isTimeDownload()'
-  print '  bool isTimeReconnect()'
-  print '  bool toggleReconnect()'
-  print '   generatePackages(LinkList links)'
-  print '   checkURLs(LinkList urls)'
-  print '   parseURLs(string html, string url)'
-  print '  OnlineCheck checkOnlineStatus(LinkList urls)'
-  print '  OnlineCheck checkOnlineStatusContainer(LinkList urls, string filename, string data)'
-  print '  OnlineCheck pollResults(ResultID rid)'
-  print '   statusDownloads()'
-  print '  PackageData getPackageData(PackageID pid)'
-  print '  PackageData getPackageInfo(PackageID pid)'
-  print '  FileData getFileData(FileID fid)'
-  print '   getQueue()'
-  print '   getCollector()'
-  print '   getQueueData()'
-  print '   getCollectorData()'
-  print '   getPackageOrder(Destination destination)'
-  print '   getFileOrder(PackageID pid)'
-  print '   generateAndAddPackages(LinkList links, Destination dest)'
-  print '  PackageID addPackage(string name, LinkList links, Destination dest)'
-  print '  void addFiles(PackageID pid, LinkList links)'
-  print '  void uploadContainer(string filename, string data)'
-  print '  void deleteFiles( fids)'
-  print '  void deletePackages( pids)'
-  print '  void pushToQueue(PackageID pid)'
-  print '  void pullFromQueue(PackageID pid)'
-  print '  void restartPackage(PackageID pid)'
-  print '  void restartFile(FileID fid)'
-  print '  void recheckPackage(PackageID pid)'
-  print '  void stopAllDownloads()'
-  print '  void stopDownloads( fids)'
-  print '  void setPackageName(PackageID pid, string name)'
-  print '  void movePackage(Destination destination, PackageID pid)'
-  print '  void moveFiles( fids, PackageID pid)'
-  print '  void orderPackage(PackageID pid, i16 position)'
-  print '  void orderFile(FileID fid, i16 position)'
-  print '  void setPackageData(PackageID pid,  data)'
-  print '   deleteFinished()'
-  print '  void restartFailed()'
-  print '   getEvents(string uuid)'
-  print '   getAccounts(bool refresh)'
-  print '   getAccountTypes()'
-  print '  void updateAccount(PluginName plugin, string account, string password,  options)'
-  print '  void removeAccount(PluginName plugin, string account)'
-  print '  bool login(string username, string password)'
-  print '  UserData getUserData(string username, string password)'
-  print '   getAllUserData()'
-  print '   getServices()'
-  print '  bool hasService(PluginName plugin, string func)'
-  print '  string call(ServiceCall info)'
-  print '   getAllInfo()'
-  print '   getInfoByPlugin(PluginName plugin)'
-  print '  bool isCaptchaWaiting()'
-  print '  CaptchaTask getCaptchaTask(bool exclusive)'
-  print '  string getCaptchaTaskStatus(TaskID tid)'
-  print '  void setCaptchaResult(TaskID tid, string result)'
-  print ''
-  sys.exit(0)
-
-pp = pprint.PrettyPrinter(indent = 2)
-host = 'localhost'
-port = 9090
-uri = ''
-framed = False
-http = False
-argi = 1
-
-if sys.argv[argi] == '-h':
-  parts = sys.argv[argi+1].split(':')
-  host = parts[0]
-  if len(parts) > 1:
-    port = int(parts[1])
-  argi += 2
-
-if sys.argv[argi] == '-u':
-  url = urlparse(sys.argv[argi+1])
-  parts = url[1].split(':')
-  host = parts[0]
-  if len(parts) > 1:
-    port = int(parts[1])
-  else:
-    port = 80
-  uri = url[2]
-  if url[4]:
-    uri += '?%s' % url[4]
-  http = True
-  argi += 2
-
-if sys.argv[argi] == '-f' or sys.argv[argi] == '-framed':
-  framed = True
-  argi += 1
-
-cmd = sys.argv[argi]
-args = sys.argv[argi+1:]
-
-if http:
-  transport = THttpClient.THttpClient(host, port, uri)
-else:
-  socket = TSocket.TSocket(host, port)
-  if framed:
-    transport = TTransport.TFramedTransport(socket)
-  else:
-    transport = TTransport.TBufferedTransport(socket)
-protocol = TBinaryProtocol.TBinaryProtocol(transport)
-client = Pyload.Client(protocol)
-transport.open()
-
-if cmd == 'getConfigValue':
-  if len(args) != 3:
-    print 'getConfigValue requires 3 args'
-    sys.exit(1)
-  pp.pprint(client.getConfigValue(args[0],args[1],args[2],))
-
-elif cmd == 'setConfigValue':
-  if len(args) != 4:
-    print 'setConfigValue requires 4 args'
-    sys.exit(1)
-  pp.pprint(client.setConfigValue(args[0],args[1],args[2],args[3],))
-
-elif cmd == 'getConfig':
-  if len(args) != 0:
-    print 'getConfig requires 0 args'
-    sys.exit(1)
-  pp.pprint(client.getConfig())
-
-elif cmd == 'getPluginConfig':
-  if len(args) != 0:
-    print 'getPluginConfig requires 0 args'
-    sys.exit(1)
-  pp.pprint(client.getPluginConfig())
-
-elif cmd == 'pauseServer':
-  if len(args) != 0:
-    print 'pauseServer requires 0 args'
-    sys.exit(1)
-  pp.pprint(client.pauseServer())
-
-elif cmd == 'unpauseServer':
-  if len(args) != 0:
-    print 'unpauseServer requires 0 args'
-    sys.exit(1)
-  pp.pprint(client.unpauseServer())
-
-elif cmd == 'togglePause':
-  if len(args) != 0:
-    print 'togglePause requires 0 args'
-    sys.exit(1)
-  pp.pprint(client.togglePause())
-
-elif cmd == 'statusServer':
-  if len(args) != 0:
-    print 'statusServer requires 0 args'
-    sys.exit(1)
-  pp.pprint(client.statusServer())
-
-elif cmd == 'freeSpace':
-  if len(args) != 0:
-    print 'freeSpace requires 0 args'
-    sys.exit(1)
-  pp.pprint(client.freeSpace())
-
-elif cmd == 'getServerVersion':
-  if len(args) != 0:
-    print 'getServerVersion requires 0 args'
-    sys.exit(1)
-  pp.pprint(client.getServerVersion())
-
-elif cmd == 'kill':
-  if len(args) != 0:
-    print 'kill requires 0 args'
-    sys.exit(1)
-  pp.pprint(client.kill())
-
-elif cmd == 'restart':
-  if len(args) != 0:
-    print 'restart requires 0 args'
-    sys.exit(1)
-  pp.pprint(client.restart())
-
-elif cmd == 'getLog':
-  if len(args) != 1:
-    print 'getLog requires 1 args'
-    sys.exit(1)
-  pp.pprint(client.getLog(eval(args[0]),))
-
-elif cmd == 'isTimeDownload':
-  if len(args) != 0:
-    print 'isTimeDownload requires 0 args'
-    sys.exit(1)
-  pp.pprint(client.isTimeDownload())
-
-elif cmd == 'isTimeReconnect':
-  if len(args) != 0:
-    print 'isTimeReconnect requires 0 args'
-    sys.exit(1)
-  pp.pprint(client.isTimeReconnect())
-
-elif cmd == 'toggleReconnect':
-  if len(args) != 0:
-    print 'toggleReconnect requires 0 args'
-    sys.exit(1)
-  pp.pprint(client.toggleReconnect())
-
-elif cmd == 'generatePackages':
-  if len(args) != 1:
-    print 'generatePackages requires 1 args'
-    sys.exit(1)
-  pp.pprint(client.generatePackages(eval(args[0]),))
-
-elif cmd == 'checkURLs':
-  if len(args) != 1:
-    print 'checkURLs requires 1 args'
-    sys.exit(1)
-  pp.pprint(client.checkURLs(eval(args[0]),))
-
-elif cmd == 'parseURLs':
-  if len(args) != 2:
-    print 'parseURLs requires 2 args'
-    sys.exit(1)
-  pp.pprint(client.parseURLs(args[0],args[1],))
-
-elif cmd == 'checkOnlineStatus':
-  if len(args) != 1:
-    print 'checkOnlineStatus requires 1 args'
-    sys.exit(1)
-  pp.pprint(client.checkOnlineStatus(eval(args[0]),))
-
-elif cmd == 'checkOnlineStatusContainer':
-  if len(args) != 3:
-    print 'checkOnlineStatusContainer requires 3 args'
-    sys.exit(1)
-  pp.pprint(client.checkOnlineStatusContainer(eval(args[0]),args[1],args[2],))
-
-elif cmd == 'pollResults':
-  if len(args) != 1:
-    print 'pollResults requires 1 args'
-    sys.exit(1)
-  pp.pprint(client.pollResults(eval(args[0]),))
-
-elif cmd == 'statusDownloads':
-  if len(args) != 0:
-    print 'statusDownloads requires 0 args'
-    sys.exit(1)
-  pp.pprint(client.statusDownloads())
-
-elif cmd == 'getPackageData':
-  if len(args) != 1:
-    print 'getPackageData requires 1 args'
-    sys.exit(1)
-  pp.pprint(client.getPackageData(eval(args[0]),))
-
-elif cmd == 'getPackageInfo':
-  if len(args) != 1:
-    print 'getPackageInfo requires 1 args'
-    sys.exit(1)
-  pp.pprint(client.getPackageInfo(eval(args[0]),))
-
-elif cmd == 'getFileData':
-  if len(args) != 1:
-    print 'getFileData requires 1 args'
-    sys.exit(1)
-  pp.pprint(client.getFileData(eval(args[0]),))
-
-elif cmd == 'getQueue':
-  if len(args) != 0:
-    print 'getQueue requires 0 args'
-    sys.exit(1)
-  pp.pprint(client.getQueue())
-
-elif cmd == 'getCollector':
-  if len(args) != 0:
-    print 'getCollector requires 0 args'
-    sys.exit(1)
-  pp.pprint(client.getCollector())
-
-elif cmd == 'getQueueData':
-  if len(args) != 0:
-    print 'getQueueData requires 0 args'
-    sys.exit(1)
-  pp.pprint(client.getQueueData())
-
-elif cmd == 'getCollectorData':
-  if len(args) != 0:
-    print 'getCollectorData requires 0 args'
-    sys.exit(1)
-  pp.pprint(client.getCollectorData())
-
-elif cmd == 'getPackageOrder':
-  if len(args) != 1:
-    print 'getPackageOrder requires 1 args'
-    sys.exit(1)
-  pp.pprint(client.getPackageOrder(eval(args[0]),))
-
-elif cmd == 'getFileOrder':
-  if len(args) != 1:
-    print 'getFileOrder requires 1 args'
-    sys.exit(1)
-  pp.pprint(client.getFileOrder(eval(args[0]),))
-
-elif cmd == 'generateAndAddPackages':
-  if len(args) != 2:
-    print 'generateAndAddPackages requires 2 args'
-    sys.exit(1)
-  pp.pprint(client.generateAndAddPackages(eval(args[0]),eval(args[1]),))
-
-elif cmd == 'addPackage':
-  if len(args) != 3:
-    print 'addPackage requires 3 args'
-    sys.exit(1)
-  pp.pprint(client.addPackage(args[0],eval(args[1]),eval(args[2]),))
-
-elif cmd == 'addFiles':
-  if len(args) != 2:
-    print 'addFiles requires 2 args'
-    sys.exit(1)
-  pp.pprint(client.addFiles(eval(args[0]),eval(args[1]),))
-
-elif cmd == 'uploadContainer':
-  if len(args) != 2:
-    print 'uploadContainer requires 2 args'
-    sys.exit(1)
-  pp.pprint(client.uploadContainer(args[0],args[1],))
-
-elif cmd == 'deleteFiles':
-  if len(args) != 1:
-    print 'deleteFiles requires 1 args'
-    sys.exit(1)
-  pp.pprint(client.deleteFiles(eval(args[0]),))
-
-elif cmd == 'deletePackages':
-  if len(args) != 1:
-    print 'deletePackages requires 1 args'
-    sys.exit(1)
-  pp.pprint(client.deletePackages(eval(args[0]),))
-
-elif cmd == 'pushToQueue':
-  if len(args) != 1:
-    print 'pushToQueue requires 1 args'
-    sys.exit(1)
-  pp.pprint(client.pushToQueue(eval(args[0]),))
-
-elif cmd == 'pullFromQueue':
-  if len(args) != 1:
-    print 'pullFromQueue requires 1 args'
-    sys.exit(1)
-  pp.pprint(client.pullFromQueue(eval(args[0]),))
-
-elif cmd == 'restartPackage':
-  if len(args) != 1:
-    print 'restartPackage requires 1 args'
-    sys.exit(1)
-  pp.pprint(client.restartPackage(eval(args[0]),))
-
-elif cmd == 'restartFile':
-  if len(args) != 1:
-    print 'restartFile requires 1 args'
-    sys.exit(1)
-  pp.pprint(client.restartFile(eval(args[0]),))
-
-elif cmd == 'recheckPackage':
-  if len(args) != 1:
-    print 'recheckPackage requires 1 args'
-    sys.exit(1)
-  pp.pprint(client.recheckPackage(eval(args[0]),))
-
-elif cmd == 'stopAllDownloads':
-  if len(args) != 0:
-    print 'stopAllDownloads requires 0 args'
-    sys.exit(1)
-  pp.pprint(client.stopAllDownloads())
-
-elif cmd == 'stopDownloads':
-  if len(args) != 1:
-    print 'stopDownloads requires 1 args'
-    sys.exit(1)
-  pp.pprint(client.stopDownloads(eval(args[0]),))
-
-elif cmd == 'setPackageName':
-  if len(args) != 2:
-    print 'setPackageName requires 2 args'
-    sys.exit(1)
-  pp.pprint(client.setPackageName(eval(args[0]),args[1],))
-
-elif cmd == 'movePackage':
-  if len(args) != 2:
-    print 'movePackage requires 2 args'
-    sys.exit(1)
-  pp.pprint(client.movePackage(eval(args[0]),eval(args[1]),))
-
-elif cmd == 'moveFiles':
-  if len(args) != 2:
-    print 'moveFiles requires 2 args'
-    sys.exit(1)
-  pp.pprint(client.moveFiles(eval(args[0]),eval(args[1]),))
-
-elif cmd == 'orderPackage':
-  if len(args) != 2:
-    print 'orderPackage requires 2 args'
-    sys.exit(1)
-  pp.pprint(client.orderPackage(eval(args[0]),eval(args[1]),))
-
-elif cmd == 'orderFile':
-  if len(args) != 2:
-    print 'orderFile requires 2 args'
-    sys.exit(1)
-  pp.pprint(client.orderFile(eval(args[0]),eval(args[1]),))
-
-elif cmd == 'setPackageData':
-  if len(args) != 2:
-    print 'setPackageData requires 2 args'
-    sys.exit(1)
-  pp.pprint(client.setPackageData(eval(args[0]),eval(args[1]),))
-
-elif cmd == 'deleteFinished':
-  if len(args) != 0:
-    print 'deleteFinished requires 0 args'
-    sys.exit(1)
-  pp.pprint(client.deleteFinished())
-
-elif cmd == 'restartFailed':
-  if len(args) != 0:
-    print 'restartFailed requires 0 args'
-    sys.exit(1)
-  pp.pprint(client.restartFailed())
-
-elif cmd == 'getEvents':
-  if len(args) != 1:
-    print 'getEvents requires 1 args'
-    sys.exit(1)
-  pp.pprint(client.getEvents(args[0],))
-
-elif cmd == 'getAccounts':
-  if len(args) != 1:
-    print 'getAccounts requires 1 args'
-    sys.exit(1)
-  pp.pprint(client.getAccounts(eval(args[0]),))
-
-elif cmd == 'getAccountTypes':
-  if len(args) != 0:
-    print 'getAccountTypes requires 0 args'
-    sys.exit(1)
-  pp.pprint(client.getAccountTypes())
-
-elif cmd == 'updateAccount':
-  if len(args) != 4:
-    print 'updateAccount requires 4 args'
-    sys.exit(1)
-  pp.pprint(client.updateAccount(eval(args[0]),args[1],args[2],eval(args[3]),))
-
-elif cmd == 'removeAccount':
-  if len(args) != 2:
-    print 'removeAccount requires 2 args'
-    sys.exit(1)
-  pp.pprint(client.removeAccount(eval(args[0]),args[1],))
-
-elif cmd == 'login':
-  if len(args) != 2:
-    print 'login requires 2 args'
-    sys.exit(1)
-  pp.pprint(client.login(args[0],args[1],))
-
-elif cmd == 'getUserData':
-  if len(args) != 2:
-    print 'getUserData requires 2 args'
-    sys.exit(1)
-  pp.pprint(client.getUserData(args[0],args[1],))
-
-elif cmd == 'getAllUserData':
-  if len(args) != 0:
-    print 'getAllUserData requires 0 args'
-    sys.exit(1)
-  pp.pprint(client.getAllUserData())
-
-elif cmd == 'getServices':
-  if len(args) != 0:
-    print 'getServices requires 0 args'
-    sys.exit(1)
-  pp.pprint(client.getServices())
-
-elif cmd == 'hasService':
-  if len(args) != 2:
-    print 'hasService requires 2 args'
-    sys.exit(1)
-  pp.pprint(client.hasService(eval(args[0]),args[1],))
-
-elif cmd == 'call':
-  if len(args) != 1:
-    print 'call requires 1 args'
-    sys.exit(1)
-  pp.pprint(client.call(eval(args[0]),))
-
-elif cmd == 'getAllInfo':
-  if len(args) != 0:
-    print 'getAllInfo requires 0 args'
-    sys.exit(1)
-  pp.pprint(client.getAllInfo())
-
-elif cmd == 'getInfoByPlugin':
-  if len(args) != 1:
-    print 'getInfoByPlugin requires 1 args'
-    sys.exit(1)
-  pp.pprint(client.getInfoByPlugin(eval(args[0]),))
-
-elif cmd == 'isCaptchaWaiting':
-  if len(args) != 0:
-    print 'isCaptchaWaiting requires 0 args'
-    sys.exit(1)
-  pp.pprint(client.isCaptchaWaiting())
-
-elif cmd == 'getCaptchaTask':
-  if len(args) != 1:
-    print 'getCaptchaTask requires 1 args'
-    sys.exit(1)
-  pp.pprint(client.getCaptchaTask(eval(args[0]),))
-
-elif cmd == 'getCaptchaTaskStatus':
-  if len(args) != 1:
-    print 'getCaptchaTaskStatus requires 1 args'
-    sys.exit(1)
-  pp.pprint(client.getCaptchaTaskStatus(eval(args[0]),))
-
-elif cmd == 'setCaptchaResult':
-  if len(args) != 2:
-    print 'setCaptchaResult requires 2 args'
-    sys.exit(1)
-  pp.pprint(client.setCaptchaResult(eval(args[0]),args[1],))
-
-else:
-  print 'Unrecognized method %s' % cmd
-  sys.exit(1)
-
-transport.close()
diff --git a/module/remote/thriftbackend/thriftgen/pyload/Pyload.py b/module/remote/thriftbackend/thriftgen/pyload/Pyload.py
deleted file mode 100644
index 78a42f16a..000000000
--- a/module/remote/thriftbackend/thriftgen/pyload/Pyload.py
+++ /dev/null
@@ -1,5534 +0,0 @@
-#
-# Autogenerated by Thrift Compiler (0.9.0-dev)
-#
-# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
-#
-#  options string: py:slots,dynamic
-#
-
-from thrift.Thrift import TType, TMessageType, TException
-from ttypes import *
-from thrift.Thrift import TProcessor
-from thrift.protocol.TBase import TBase, TExceptionBase
-
-
-class Iface(object):
-  def getConfigValue(self, category, option, section):
-    """
-    Parameters:
-     - category
-     - option
-     - section
-    """
-    pass
-
-  def setConfigValue(self, category, option, value, section):
-    """
-    Parameters:
-     - category
-     - option
-     - value
-     - section
-    """
-    pass
-
-  def getConfig(self, ):
-    pass
-
-  def getPluginConfig(self, ):
-    pass
-
-  def pauseServer(self, ):
-    pass
-
-  def unpauseServer(self, ):
-    pass
-
-  def togglePause(self, ):
-    pass
-
-  def statusServer(self, ):
-    pass
-
-  def freeSpace(self, ):
-    pass
-
-  def getServerVersion(self, ):
-    pass
-
-  def kill(self, ):
-    pass
-
-  def restart(self, ):
-    pass
-
-  def getLog(self, offset):
-    """
-    Parameters:
-     - offset
-    """
-    pass
-
-  def isTimeDownload(self, ):
-    pass
-
-  def isTimeReconnect(self, ):
-    pass
-
-  def toggleReconnect(self, ):
-    pass
-
-  def generatePackages(self, links):
-    """
-    Parameters:
-     - links
-    """
-    pass
-
-  def checkURLs(self, urls):
-    """
-    Parameters:
-     - urls
-    """
-    pass
-
-  def parseURLs(self, html, url):
-    """
-    Parameters:
-     - html
-     - url
-    """
-    pass
-
-  def checkOnlineStatus(self, urls):
-    """
-    Parameters:
-     - urls
-    """
-    pass
-
-  def checkOnlineStatusContainer(self, urls, filename, data):
-    """
-    Parameters:
-     - urls
-     - filename
-     - data
-    """
-    pass
-
-  def pollResults(self, rid):
-    """
-    Parameters:
-     - rid
-    """
-    pass
-
-  def statusDownloads(self, ):
-    pass
-
-  def getPackageData(self, pid):
-    """
-    Parameters:
-     - pid
-    """
-    pass
-
-  def getPackageInfo(self, pid):
-    """
-    Parameters:
-     - pid
-    """
-    pass
-
-  def getFileData(self, fid):
-    """
-    Parameters:
-     - fid
-    """
-    pass
-
-  def getQueue(self, ):
-    pass
-
-  def getCollector(self, ):
-    pass
-
-  def getQueueData(self, ):
-    pass
-
-  def getCollectorData(self, ):
-    pass
-
-  def getPackageOrder(self, destination):
-    """
-    Parameters:
-     - destination
-    """
-    pass
-
-  def getFileOrder(self, pid):
-    """
-    Parameters:
-     - pid
-    """
-    pass
-
-  def generateAndAddPackages(self, links, dest):
-    """
-    Parameters:
-     - links
-     - dest
-    """
-    pass
-
-  def addPackage(self, name, links, dest):
-    """
-    Parameters:
-     - name
-     - links
-     - dest
-    """
-    pass
-
-  def addFiles(self, pid, links):
-    """
-    Parameters:
-     - pid
-     - links
-    """
-    pass
-
-  def uploadContainer(self, filename, data):
-    """
-    Parameters:
-     - filename
-     - data
-    """
-    pass
-
-  def deleteFiles(self, fids):
-    """
-    Parameters:
-     - fids
-    """
-    pass
-
-  def deletePackages(self, pids):
-    """
-    Parameters:
-     - pids
-    """
-    pass
-
-  def pushToQueue(self, pid):
-    """
-    Parameters:
-     - pid
-    """
-    pass
-
-  def pullFromQueue(self, pid):
-    """
-    Parameters:
-     - pid
-    """
-    pass
-
-  def restartPackage(self, pid):
-    """
-    Parameters:
-     - pid
-    """
-    pass
-
-  def restartFile(self, fid):
-    """
-    Parameters:
-     - fid
-    """
-    pass
-
-  def recheckPackage(self, pid):
-    """
-    Parameters:
-     - pid
-    """
-    pass
-
-  def stopAllDownloads(self, ):
-    pass
-
-  def stopDownloads(self, fids):
-    """
-    Parameters:
-     - fids
-    """
-    pass
-
-  def setPackageName(self, pid, name):
-    """
-    Parameters:
-     - pid
-     - name
-    """
-    pass
-
-  def movePackage(self, destination, pid):
-    """
-    Parameters:
-     - destination
-     - pid
-    """
-    pass
-
-  def moveFiles(self, fids, pid):
-    """
-    Parameters:
-     - fids
-     - pid
-    """
-    pass
-
-  def orderPackage(self, pid, position):
-    """
-    Parameters:
-     - pid
-     - position
-    """
-    pass
-
-  def orderFile(self, fid, position):
-    """
-    Parameters:
-     - fid
-     - position
-    """
-    pass
-
-  def setPackageData(self, pid, data):
-    """
-    Parameters:
-     - pid
-     - data
-    """
-    pass
-
-  def deleteFinished(self, ):
-    pass
-
-  def restartFailed(self, ):
-    pass
-
-  def getEvents(self, uuid):
-    """
-    Parameters:
-     - uuid
-    """
-    pass
-
-  def getAccounts(self, refresh):
-    """
-    Parameters:
-     - refresh
-    """
-    pass
-
-  def getAccountTypes(self, ):
-    pass
-
-  def updateAccount(self, plugin, account, password, options):
-    """
-    Parameters:
-     - plugin
-     - account
-     - password
-     - options
-    """
-    pass
-
-  def removeAccount(self, plugin, account):
-    """
-    Parameters:
-     - plugin
-     - account
-    """
-    pass
-
-  def login(self, username, password):
-    """
-    Parameters:
-     - username
-     - password
-    """
-    pass
-
-  def getUserData(self, username, password):
-    """
-    Parameters:
-     - username
-     - password
-    """
-    pass
-
-  def getAllUserData(self, ):
-    pass
-
-  def getServices(self, ):
-    pass
-
-  def hasService(self, plugin, func):
-    """
-    Parameters:
-     - plugin
-     - func
-    """
-    pass
-
-  def call(self, info):
-    """
-    Parameters:
-     - info
-    """
-    pass
-
-  def getAllInfo(self, ):
-    pass
-
-  def getInfoByPlugin(self, plugin):
-    """
-    Parameters:
-     - plugin
-    """
-    pass
-
-  def isCaptchaWaiting(self, ):
-    pass
-
-  def getCaptchaTask(self, exclusive):
-    """
-    Parameters:
-     - exclusive
-    """
-    pass
-
-  def getCaptchaTaskStatus(self, tid):
-    """
-    Parameters:
-     - tid
-    """
-    pass
-
-  def setCaptchaResult(self, tid, result):
-    """
-    Parameters:
-     - tid
-     - result
-    """
-    pass
-
-
-class Client(Iface):
-  def __init__(self, iprot, oprot=None):
-    self._iprot = self._oprot = iprot
-    if oprot is not None:
-      self._oprot = oprot
-    self._seqid = 0
-
-  def getConfigValue(self, category, option, section):
-    """
-    Parameters:
-     - category
-     - option
-     - section
-    """
-    self.send_getConfigValue(category, option, section)
-    return self.recv_getConfigValue()
-
-  def send_getConfigValue(self, category, option, section):
-    self._oprot.writeMessageBegin('getConfigValue', TMessageType.CALL, self._seqid)
-    args = getConfigValue_args()
-    args.category = category
-    args.option = option
-    args.section = section
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_getConfigValue(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = getConfigValue_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getConfigValue failed: unknown result");
-
-  def setConfigValue(self, category, option, value, section):
-    """
-    Parameters:
-     - category
-     - option
-     - value
-     - section
-    """
-    self.send_setConfigValue(category, option, value, section)
-    self.recv_setConfigValue()
-
-  def send_setConfigValue(self, category, option, value, section):
-    self._oprot.writeMessageBegin('setConfigValue', TMessageType.CALL, self._seqid)
-    args = setConfigValue_args()
-    args.category = category
-    args.option = option
-    args.value = value
-    args.section = section
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_setConfigValue(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = setConfigValue_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    return
-
-  def getConfig(self, ):
-    self.send_getConfig()
-    return self.recv_getConfig()
-
-  def send_getConfig(self, ):
-    self._oprot.writeMessageBegin('getConfig', TMessageType.CALL, self._seqid)
-    args = getConfig_args()
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_getConfig(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = getConfig_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getConfig failed: unknown result");
-
-  def getPluginConfig(self, ):
-    self.send_getPluginConfig()
-    return self.recv_getPluginConfig()
-
-  def send_getPluginConfig(self, ):
-    self._oprot.writeMessageBegin('getPluginConfig', TMessageType.CALL, self._seqid)
-    args = getPluginConfig_args()
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_getPluginConfig(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = getPluginConfig_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPluginConfig failed: unknown result");
-
-  def pauseServer(self, ):
-    self.send_pauseServer()
-    self.recv_pauseServer()
-
-  def send_pauseServer(self, ):
-    self._oprot.writeMessageBegin('pauseServer', TMessageType.CALL, self._seqid)
-    args = pauseServer_args()
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_pauseServer(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = pauseServer_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    return
-
-  def unpauseServer(self, ):
-    self.send_unpauseServer()
-    self.recv_unpauseServer()
-
-  def send_unpauseServer(self, ):
-    self._oprot.writeMessageBegin('unpauseServer', TMessageType.CALL, self._seqid)
-    args = unpauseServer_args()
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_unpauseServer(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = unpauseServer_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    return
-
-  def togglePause(self, ):
-    self.send_togglePause()
-    return self.recv_togglePause()
-
-  def send_togglePause(self, ):
-    self._oprot.writeMessageBegin('togglePause', TMessageType.CALL, self._seqid)
-    args = togglePause_args()
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_togglePause(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = togglePause_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "togglePause failed: unknown result");
-
-  def statusServer(self, ):
-    self.send_statusServer()
-    return self.recv_statusServer()
-
-  def send_statusServer(self, ):
-    self._oprot.writeMessageBegin('statusServer', TMessageType.CALL, self._seqid)
-    args = statusServer_args()
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_statusServer(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = statusServer_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "statusServer failed: unknown result");
-
-  def freeSpace(self, ):
-    self.send_freeSpace()
-    return self.recv_freeSpace()
-
-  def send_freeSpace(self, ):
-    self._oprot.writeMessageBegin('freeSpace', TMessageType.CALL, self._seqid)
-    args = freeSpace_args()
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_freeSpace(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = freeSpace_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "freeSpace failed: unknown result");
-
-  def getServerVersion(self, ):
-    self.send_getServerVersion()
-    return self.recv_getServerVersion()
-
-  def send_getServerVersion(self, ):
-    self._oprot.writeMessageBegin('getServerVersion', TMessageType.CALL, self._seqid)
-    args = getServerVersion_args()
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_getServerVersion(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = getServerVersion_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServerVersion failed: unknown result");
-
-  def kill(self, ):
-    self.send_kill()
-    self.recv_kill()
-
-  def send_kill(self, ):
-    self._oprot.writeMessageBegin('kill', TMessageType.CALL, self._seqid)
-    args = kill_args()
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_kill(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = kill_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    return
-
-  def restart(self, ):
-    self.send_restart()
-    self.recv_restart()
-
-  def send_restart(self, ):
-    self._oprot.writeMessageBegin('restart', TMessageType.CALL, self._seqid)
-    args = restart_args()
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_restart(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = restart_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    return
-
-  def getLog(self, offset):
-    """
-    Parameters:
-     - offset
-    """
-    self.send_getLog(offset)
-    return self.recv_getLog()
-
-  def send_getLog(self, offset):
-    self._oprot.writeMessageBegin('getLog', TMessageType.CALL, self._seqid)
-    args = getLog_args()
-    args.offset = offset
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_getLog(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = getLog_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLog failed: unknown result");
-
-  def isTimeDownload(self, ):
-    self.send_isTimeDownload()
-    return self.recv_isTimeDownload()
-
-  def send_isTimeDownload(self, ):
-    self._oprot.writeMessageBegin('isTimeDownload', TMessageType.CALL, self._seqid)
-    args = isTimeDownload_args()
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_isTimeDownload(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = isTimeDownload_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "isTimeDownload failed: unknown result");
-
-  def isTimeReconnect(self, ):
-    self.send_isTimeReconnect()
-    return self.recv_isTimeReconnect()
-
-  def send_isTimeReconnect(self, ):
-    self._oprot.writeMessageBegin('isTimeReconnect', TMessageType.CALL, self._seqid)
-    args = isTimeReconnect_args()
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_isTimeReconnect(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = isTimeReconnect_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "isTimeReconnect failed: unknown result");
-
-  def toggleReconnect(self, ):
-    self.send_toggleReconnect()
-    return self.recv_toggleReconnect()
-
-  def send_toggleReconnect(self, ):
-    self._oprot.writeMessageBegin('toggleReconnect', TMessageType.CALL, self._seqid)
-    args = toggleReconnect_args()
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_toggleReconnect(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = toggleReconnect_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleReconnect failed: unknown result");
-
-  def generatePackages(self, links):
-    """
-    Parameters:
-     - links
-    """
-    self.send_generatePackages(links)
-    return self.recv_generatePackages()
-
-  def send_generatePackages(self, links):
-    self._oprot.writeMessageBegin('generatePackages', TMessageType.CALL, self._seqid)
-    args = generatePackages_args()
-    args.links = links
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_generatePackages(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = generatePackages_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "generatePackages failed: unknown result");
-
-  def checkURLs(self, urls):
-    """
-    Parameters:
-     - urls
-    """
-    self.send_checkURLs(urls)
-    return self.recv_checkURLs()
-
-  def send_checkURLs(self, urls):
-    self._oprot.writeMessageBegin('checkURLs', TMessageType.CALL, self._seqid)
-    args = checkURLs_args()
-    args.urls = urls
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_checkURLs(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = checkURLs_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkURLs failed: unknown result");
-
-  def parseURLs(self, html, url):
-    """
-    Parameters:
-     - html
-     - url
-    """
-    self.send_parseURLs(html, url)
-    return self.recv_parseURLs()
-
-  def send_parseURLs(self, html, url):
-    self._oprot.writeMessageBegin('parseURLs', TMessageType.CALL, self._seqid)
-    args = parseURLs_args()
-    args.html = html
-    args.url = url
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_parseURLs(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = parseURLs_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "parseURLs failed: unknown result");
-
-  def checkOnlineStatus(self, urls):
-    """
-    Parameters:
-     - urls
-    """
-    self.send_checkOnlineStatus(urls)
-    return self.recv_checkOnlineStatus()
-
-  def send_checkOnlineStatus(self, urls):
-    self._oprot.writeMessageBegin('checkOnlineStatus', TMessageType.CALL, self._seqid)
-    args = checkOnlineStatus_args()
-    args.urls = urls
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_checkOnlineStatus(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = checkOnlineStatus_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOnlineStatus failed: unknown result");
-
-  def checkOnlineStatusContainer(self, urls, filename, data):
-    """
-    Parameters:
-     - urls
-     - filename
-     - data
-    """
-    self.send_checkOnlineStatusContainer(urls, filename, data)
-    return self.recv_checkOnlineStatusContainer()
-
-  def send_checkOnlineStatusContainer(self, urls, filename, data):
-    self._oprot.writeMessageBegin('checkOnlineStatusContainer', TMessageType.CALL, self._seqid)
-    args = checkOnlineStatusContainer_args()
-    args.urls = urls
-    args.filename = filename
-    args.data = data
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_checkOnlineStatusContainer(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = checkOnlineStatusContainer_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOnlineStatusContainer failed: unknown result");
-
-  def pollResults(self, rid):
-    """
-    Parameters:
-     - rid
-    """
-    self.send_pollResults(rid)
-    return self.recv_pollResults()
-
-  def send_pollResults(self, rid):
-    self._oprot.writeMessageBegin('pollResults', TMessageType.CALL, self._seqid)
-    args = pollResults_args()
-    args.rid = rid
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_pollResults(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = pollResults_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "pollResults failed: unknown result");
-
-  def statusDownloads(self, ):
-    self.send_statusDownloads()
-    return self.recv_statusDownloads()
-
-  def send_statusDownloads(self, ):
-    self._oprot.writeMessageBegin('statusDownloads', TMessageType.CALL, self._seqid)
-    args = statusDownloads_args()
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_statusDownloads(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = statusDownloads_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "statusDownloads failed: unknown result");
-
-  def getPackageData(self, pid):
-    """
-    Parameters:
-     - pid
-    """
-    self.send_getPackageData(pid)
-    return self.recv_getPackageData()
-
-  def send_getPackageData(self, pid):
-    self._oprot.writeMessageBegin('getPackageData', TMessageType.CALL, self._seqid)
-    args = getPackageData_args()
-    args.pid = pid
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_getPackageData(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = getPackageData_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    if result.e is not None:
-      raise result.e
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPackageData failed: unknown result");
-
-  def getPackageInfo(self, pid):
-    """
-    Parameters:
-     - pid
-    """
-    self.send_getPackageInfo(pid)
-    return self.recv_getPackageInfo()
-
-  def send_getPackageInfo(self, pid):
-    self._oprot.writeMessageBegin('getPackageInfo', TMessageType.CALL, self._seqid)
-    args = getPackageInfo_args()
-    args.pid = pid
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_getPackageInfo(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = getPackageInfo_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    if result.e is not None:
-      raise result.e
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPackageInfo failed: unknown result");
-
-  def getFileData(self, fid):
-    """
-    Parameters:
-     - fid
-    """
-    self.send_getFileData(fid)
-    return self.recv_getFileData()
-
-  def send_getFileData(self, fid):
-    self._oprot.writeMessageBegin('getFileData', TMessageType.CALL, self._seqid)
-    args = getFileData_args()
-    args.fid = fid
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_getFileData(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = getFileData_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    if result.e is not None:
-      raise result.e
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFileData failed: unknown result");
-
-  def getQueue(self, ):
-    self.send_getQueue()
-    return self.recv_getQueue()
-
-  def send_getQueue(self, ):
-    self._oprot.writeMessageBegin('getQueue', TMessageType.CALL, self._seqid)
-    args = getQueue_args()
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_getQueue(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = getQueue_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getQueue failed: unknown result");
-
-  def getCollector(self, ):
-    self.send_getCollector()
-    return self.recv_getCollector()
-
-  def send_getCollector(self, ):
-    self._oprot.writeMessageBegin('getCollector', TMessageType.CALL, self._seqid)
-    args = getCollector_args()
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_getCollector(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = getCollector_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCollector failed: unknown result");
-
-  def getQueueData(self, ):
-    self.send_getQueueData()
-    return self.recv_getQueueData()
-
-  def send_getQueueData(self, ):
-    self._oprot.writeMessageBegin('getQueueData', TMessageType.CALL, self._seqid)
-    args = getQueueData_args()
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_getQueueData(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = getQueueData_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getQueueData failed: unknown result");
-
-  def getCollectorData(self, ):
-    self.send_getCollectorData()
-    return self.recv_getCollectorData()
-
-  def send_getCollectorData(self, ):
-    self._oprot.writeMessageBegin('getCollectorData', TMessageType.CALL, self._seqid)
-    args = getCollectorData_args()
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_getCollectorData(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = getCollectorData_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCollectorData failed: unknown result");
-
-  def getPackageOrder(self, destination):
-    """
-    Parameters:
-     - destination
-    """
-    self.send_getPackageOrder(destination)
-    return self.recv_getPackageOrder()
-
-  def send_getPackageOrder(self, destination):
-    self._oprot.writeMessageBegin('getPackageOrder', TMessageType.CALL, self._seqid)
-    args = getPackageOrder_args()
-    args.destination = destination
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_getPackageOrder(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = getPackageOrder_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPackageOrder failed: unknown result");
-
-  def getFileOrder(self, pid):
-    """
-    Parameters:
-     - pid
-    """
-    self.send_getFileOrder(pid)
-    return self.recv_getFileOrder()
-
-  def send_getFileOrder(self, pid):
-    self._oprot.writeMessageBegin('getFileOrder', TMessageType.CALL, self._seqid)
-    args = getFileOrder_args()
-    args.pid = pid
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_getFileOrder(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = getFileOrder_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFileOrder failed: unknown result");
-
-  def generateAndAddPackages(self, links, dest):
-    """
-    Parameters:
-     - links
-     - dest
-    """
-    self.send_generateAndAddPackages(links, dest)
-    return self.recv_generateAndAddPackages()
-
-  def send_generateAndAddPackages(self, links, dest):
-    self._oprot.writeMessageBegin('generateAndAddPackages', TMessageType.CALL, self._seqid)
-    args = generateAndAddPackages_args()
-    args.links = links
-    args.dest = dest
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_generateAndAddPackages(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = generateAndAddPackages_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateAndAddPackages failed: unknown result");
-
-  def addPackage(self, name, links, dest):
-    """
-    Parameters:
-     - name
-     - links
-     - dest
-    """
-    self.send_addPackage(name, links, dest)
-    return self.recv_addPackage()
-
-  def send_addPackage(self, name, links, dest):
-    self._oprot.writeMessageBegin('addPackage', TMessageType.CALL, self._seqid)
-    args = addPackage_args()
-    args.name = name
-    args.links = links
-    args.dest = dest
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_addPackage(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = addPackage_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "addPackage failed: unknown result");
-
-  def addFiles(self, pid, links):
-    """
-    Parameters:
-     - pid
-     - links
-    """
-    self.send_addFiles(pid, links)
-    self.recv_addFiles()
-
-  def send_addFiles(self, pid, links):
-    self._oprot.writeMessageBegin('addFiles', TMessageType.CALL, self._seqid)
-    args = addFiles_args()
-    args.pid = pid
-    args.links = links
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_addFiles(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = addFiles_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    return
-
-  def uploadContainer(self, filename, data):
-    """
-    Parameters:
-     - filename
-     - data
-    """
-    self.send_uploadContainer(filename, data)
-    self.recv_uploadContainer()
-
-  def send_uploadContainer(self, filename, data):
-    self._oprot.writeMessageBegin('uploadContainer', TMessageType.CALL, self._seqid)
-    args = uploadContainer_args()
-    args.filename = filename
-    args.data = data
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_uploadContainer(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = uploadContainer_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    return
-
-  def deleteFiles(self, fids):
-    """
-    Parameters:
-     - fids
-    """
-    self.send_deleteFiles(fids)
-    self.recv_deleteFiles()
-
-  def send_deleteFiles(self, fids):
-    self._oprot.writeMessageBegin('deleteFiles', TMessageType.CALL, self._seqid)
-    args = deleteFiles_args()
-    args.fids = fids
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_deleteFiles(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = deleteFiles_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    return
-
-  def deletePackages(self, pids):
-    """
-    Parameters:
-     - pids
-    """
-    self.send_deletePackages(pids)
-    self.recv_deletePackages()
-
-  def send_deletePackages(self, pids):
-    self._oprot.writeMessageBegin('deletePackages', TMessageType.CALL, self._seqid)
-    args = deletePackages_args()
-    args.pids = pids
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_deletePackages(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = deletePackages_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    return
-
-  def pushToQueue(self, pid):
-    """
-    Parameters:
-     - pid
-    """
-    self.send_pushToQueue(pid)
-    self.recv_pushToQueue()
-
-  def send_pushToQueue(self, pid):
-    self._oprot.writeMessageBegin('pushToQueue', TMessageType.CALL, self._seqid)
-    args = pushToQueue_args()
-    args.pid = pid
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_pushToQueue(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = pushToQueue_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    return
-
-  def pullFromQueue(self, pid):
-    """
-    Parameters:
-     - pid
-    """
-    self.send_pullFromQueue(pid)
-    self.recv_pullFromQueue()
-
-  def send_pullFromQueue(self, pid):
-    self._oprot.writeMessageBegin('pullFromQueue', TMessageType.CALL, self._seqid)
-    args = pullFromQueue_args()
-    args.pid = pid
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_pullFromQueue(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = pullFromQueue_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    return
-
-  def restartPackage(self, pid):
-    """
-    Parameters:
-     - pid
-    """
-    self.send_restartPackage(pid)
-    self.recv_restartPackage()
-
-  def send_restartPackage(self, pid):
-    self._oprot.writeMessageBegin('restartPackage', TMessageType.CALL, self._seqid)
-    args = restartPackage_args()
-    args.pid = pid
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_restartPackage(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = restartPackage_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    return
-
-  def restartFile(self, fid):
-    """
-    Parameters:
-     - fid
-    """
-    self.send_restartFile(fid)
-    self.recv_restartFile()
-
-  def send_restartFile(self, fid):
-    self._oprot.writeMessageBegin('restartFile', TMessageType.CALL, self._seqid)
-    args = restartFile_args()
-    args.fid = fid
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_restartFile(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = restartFile_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    return
-
-  def recheckPackage(self, pid):
-    """
-    Parameters:
-     - pid
-    """
-    self.send_recheckPackage(pid)
-    self.recv_recheckPackage()
-
-  def send_recheckPackage(self, pid):
-    self._oprot.writeMessageBegin('recheckPackage', TMessageType.CALL, self._seqid)
-    args = recheckPackage_args()
-    args.pid = pid
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_recheckPackage(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = recheckPackage_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    return
-
-  def stopAllDownloads(self, ):
-    self.send_stopAllDownloads()
-    self.recv_stopAllDownloads()
-
-  def send_stopAllDownloads(self, ):
-    self._oprot.writeMessageBegin('stopAllDownloads', TMessageType.CALL, self._seqid)
-    args = stopAllDownloads_args()
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_stopAllDownloads(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = stopAllDownloads_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    return
-
-  def stopDownloads(self, fids):
-    """
-    Parameters:
-     - fids
-    """
-    self.send_stopDownloads(fids)
-    self.recv_stopDownloads()
-
-  def send_stopDownloads(self, fids):
-    self._oprot.writeMessageBegin('stopDownloads', TMessageType.CALL, self._seqid)
-    args = stopDownloads_args()
-    args.fids = fids
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_stopDownloads(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = stopDownloads_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    return
-
-  def setPackageName(self, pid, name):
-    """
-    Parameters:
-     - pid
-     - name
-    """
-    self.send_setPackageName(pid, name)
-    self.recv_setPackageName()
-
-  def send_setPackageName(self, pid, name):
-    self._oprot.writeMessageBegin('setPackageName', TMessageType.CALL, self._seqid)
-    args = setPackageName_args()
-    args.pid = pid
-    args.name = name
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_setPackageName(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = setPackageName_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    return
-
-  def movePackage(self, destination, pid):
-    """
-    Parameters:
-     - destination
-     - pid
-    """
-    self.send_movePackage(destination, pid)
-    self.recv_movePackage()
-
-  def send_movePackage(self, destination, pid):
-    self._oprot.writeMessageBegin('movePackage', TMessageType.CALL, self._seqid)
-    args = movePackage_args()
-    args.destination = destination
-    args.pid = pid
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_movePackage(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = movePackage_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    return
-
-  def moveFiles(self, fids, pid):
-    """
-    Parameters:
-     - fids
-     - pid
-    """
-    self.send_moveFiles(fids, pid)
-    self.recv_moveFiles()
-
-  def send_moveFiles(self, fids, pid):
-    self._oprot.writeMessageBegin('moveFiles', TMessageType.CALL, self._seqid)
-    args = moveFiles_args()
-    args.fids = fids
-    args.pid = pid
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_moveFiles(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = moveFiles_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    return
-
-  def orderPackage(self, pid, position):
-    """
-    Parameters:
-     - pid
-     - position
-    """
-    self.send_orderPackage(pid, position)
-    self.recv_orderPackage()
-
-  def send_orderPackage(self, pid, position):
-    self._oprot.writeMessageBegin('orderPackage', TMessageType.CALL, self._seqid)
-    args = orderPackage_args()
-    args.pid = pid
-    args.position = position
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_orderPackage(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = orderPackage_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    return
-
-  def orderFile(self, fid, position):
-    """
-    Parameters:
-     - fid
-     - position
-    """
-    self.send_orderFile(fid, position)
-    self.recv_orderFile()
-
-  def send_orderFile(self, fid, position):
-    self._oprot.writeMessageBegin('orderFile', TMessageType.CALL, self._seqid)
-    args = orderFile_args()
-    args.fid = fid
-    args.position = position
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_orderFile(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = orderFile_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    return
-
-  def setPackageData(self, pid, data):
-    """
-    Parameters:
-     - pid
-     - data
-    """
-    self.send_setPackageData(pid, data)
-    self.recv_setPackageData()
-
-  def send_setPackageData(self, pid, data):
-    self._oprot.writeMessageBegin('setPackageData', TMessageType.CALL, self._seqid)
-    args = setPackageData_args()
-    args.pid = pid
-    args.data = data
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_setPackageData(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = setPackageData_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.e is not None:
-      raise result.e
-    return
-
-  def deleteFinished(self, ):
-    self.send_deleteFinished()
-    return self.recv_deleteFinished()
-
-  def send_deleteFinished(self, ):
-    self._oprot.writeMessageBegin('deleteFinished', TMessageType.CALL, self._seqid)
-    args = deleteFinished_args()
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_deleteFinished(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = deleteFinished_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteFinished failed: unknown result");
-
-  def restartFailed(self, ):
-    self.send_restartFailed()
-    self.recv_restartFailed()
-
-  def send_restartFailed(self, ):
-    self._oprot.writeMessageBegin('restartFailed', TMessageType.CALL, self._seqid)
-    args = restartFailed_args()
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_restartFailed(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = restartFailed_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    return
-
-  def getEvents(self, uuid):
-    """
-    Parameters:
-     - uuid
-    """
-    self.send_getEvents(uuid)
-    return self.recv_getEvents()
-
-  def send_getEvents(self, uuid):
-    self._oprot.writeMessageBegin('getEvents', TMessageType.CALL, self._seqid)
-    args = getEvents_args()
-    args.uuid = uuid
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_getEvents(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = getEvents_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEvents failed: unknown result");
-
-  def getAccounts(self, refresh):
-    """
-    Parameters:
-     - refresh
-    """
-    self.send_getAccounts(refresh)
-    return self.recv_getAccounts()
-
-  def send_getAccounts(self, refresh):
-    self._oprot.writeMessageBegin('getAccounts', TMessageType.CALL, self._seqid)
-    args = getAccounts_args()
-    args.refresh = refresh
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_getAccounts(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = getAccounts_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAccounts failed: unknown result");
-
-  def getAccountTypes(self, ):
-    self.send_getAccountTypes()
-    return self.recv_getAccountTypes()
-
-  def send_getAccountTypes(self, ):
-    self._oprot.writeMessageBegin('getAccountTypes', TMessageType.CALL, self._seqid)
-    args = getAccountTypes_args()
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_getAccountTypes(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = getAccountTypes_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAccountTypes failed: unknown result");
-
-  def updateAccount(self, plugin, account, password, options):
-    """
-    Parameters:
-     - plugin
-     - account
-     - password
-     - options
-    """
-    self.send_updateAccount(plugin, account, password, options)
-    self.recv_updateAccount()
-
-  def send_updateAccount(self, plugin, account, password, options):
-    self._oprot.writeMessageBegin('updateAccount', TMessageType.CALL, self._seqid)
-    args = updateAccount_args()
-    args.plugin = plugin
-    args.account = account
-    args.password = password
-    args.options = options
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_updateAccount(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = updateAccount_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    return
-
-  def removeAccount(self, plugin, account):
-    """
-    Parameters:
-     - plugin
-     - account
-    """
-    self.send_removeAccount(plugin, account)
-    self.recv_removeAccount()
-
-  def send_removeAccount(self, plugin, account):
-    self._oprot.writeMessageBegin('removeAccount', TMessageType.CALL, self._seqid)
-    args = removeAccount_args()
-    args.plugin = plugin
-    args.account = account
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_removeAccount(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = removeAccount_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    return
-
-  def login(self, username, password):
-    """
-    Parameters:
-     - username
-     - password
-    """
-    self.send_login(username, password)
-    return self.recv_login()
-
-  def send_login(self, username, password):
-    self._oprot.writeMessageBegin('login', TMessageType.CALL, self._seqid)
-    args = login_args()
-    args.username = username
-    args.password = password
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_login(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = login_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "login failed: unknown result");
-
-  def getUserData(self, username, password):
-    """
-    Parameters:
-     - username
-     - password
-    """
-    self.send_getUserData(username, password)
-    return self.recv_getUserData()
-
-  def send_getUserData(self, username, password):
-    self._oprot.writeMessageBegin('getUserData', TMessageType.CALL, self._seqid)
-    args = getUserData_args()
-    args.username = username
-    args.password = password
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_getUserData(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = getUserData_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserData failed: unknown result");
-
-  def getAllUserData(self, ):
-    self.send_getAllUserData()
-    return self.recv_getAllUserData()
-
-  def send_getAllUserData(self, ):
-    self._oprot.writeMessageBegin('getAllUserData', TMessageType.CALL, self._seqid)
-    args = getAllUserData_args()
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_getAllUserData(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = getAllUserData_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserData failed: unknown result");
-
-  def getServices(self, ):
-    self.send_getServices()
-    return self.recv_getServices()
-
-  def send_getServices(self, ):
-    self._oprot.writeMessageBegin('getServices', TMessageType.CALL, self._seqid)
-    args = getServices_args()
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_getServices(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = getServices_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServices failed: unknown result");
-
-  def hasService(self, plugin, func):
-    """
-    Parameters:
-     - plugin
-     - func
-    """
-    self.send_hasService(plugin, func)
-    return self.recv_hasService()
-
-  def send_hasService(self, plugin, func):
-    self._oprot.writeMessageBegin('hasService', TMessageType.CALL, self._seqid)
-    args = hasService_args()
-    args.plugin = plugin
-    args.func = func
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_hasService(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = hasService_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "hasService failed: unknown result");
-
-  def call(self, info):
-    """
-    Parameters:
-     - info
-    """
-    self.send_call(info)
-    return self.recv_call()
-
-  def send_call(self, info):
-    self._oprot.writeMessageBegin('call', TMessageType.CALL, self._seqid)
-    args = call_args()
-    args.info = info
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_call(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = call_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    if result.ex is not None:
-      raise result.ex
-    if result.e is not None:
-      raise result.e
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "call failed: unknown result");
-
-  def getAllInfo(self, ):
-    self.send_getAllInfo()
-    return self.recv_getAllInfo()
-
-  def send_getAllInfo(self, ):
-    self._oprot.writeMessageBegin('getAllInfo', TMessageType.CALL, self._seqid)
-    args = getAllInfo_args()
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_getAllInfo(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = getAllInfo_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInfo failed: unknown result");
-
-  def getInfoByPlugin(self, plugin):
-    """
-    Parameters:
-     - plugin
-    """
-    self.send_getInfoByPlugin(plugin)
-    return self.recv_getInfoByPlugin()
-
-  def send_getInfoByPlugin(self, plugin):
-    self._oprot.writeMessageBegin('getInfoByPlugin', TMessageType.CALL, self._seqid)
-    args = getInfoByPlugin_args()
-    args.plugin = plugin
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_getInfoByPlugin(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = getInfoByPlugin_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInfoByPlugin failed: unknown result");
-
-  def isCaptchaWaiting(self, ):
-    self.send_isCaptchaWaiting()
-    return self.recv_isCaptchaWaiting()
-
-  def send_isCaptchaWaiting(self, ):
-    self._oprot.writeMessageBegin('isCaptchaWaiting', TMessageType.CALL, self._seqid)
-    args = isCaptchaWaiting_args()
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_isCaptchaWaiting(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = isCaptchaWaiting_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "isCaptchaWaiting failed: unknown result");
-
-  def getCaptchaTask(self, exclusive):
-    """
-    Parameters:
-     - exclusive
-    """
-    self.send_getCaptchaTask(exclusive)
-    return self.recv_getCaptchaTask()
-
-  def send_getCaptchaTask(self, exclusive):
-    self._oprot.writeMessageBegin('getCaptchaTask', TMessageType.CALL, self._seqid)
-    args = getCaptchaTask_args()
-    args.exclusive = exclusive
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_getCaptchaTask(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = getCaptchaTask_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCaptchaTask failed: unknown result");
-
-  def getCaptchaTaskStatus(self, tid):
-    """
-    Parameters:
-     - tid
-    """
-    self.send_getCaptchaTaskStatus(tid)
-    return self.recv_getCaptchaTaskStatus()
-
-  def send_getCaptchaTaskStatus(self, tid):
-    self._oprot.writeMessageBegin('getCaptchaTaskStatus', TMessageType.CALL, self._seqid)
-    args = getCaptchaTaskStatus_args()
-    args.tid = tid
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_getCaptchaTaskStatus(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = getCaptchaTaskStatus_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCaptchaTaskStatus failed: unknown result");
-
-  def setCaptchaResult(self, tid, result):
-    """
-    Parameters:
-     - tid
-     - result
-    """
-    self.send_setCaptchaResult(tid, result)
-    self.recv_setCaptchaResult()
-
-  def send_setCaptchaResult(self, tid, result):
-    self._oprot.writeMessageBegin('setCaptchaResult', TMessageType.CALL, self._seqid)
-    args = setCaptchaResult_args()
-    args.tid = tid
-    args.result = result
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_setCaptchaResult(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = setCaptchaResult_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    return
-
-
-class Processor(Iface, TProcessor):
-  def __init__(self, handler):
-    self._handler = handler
-    self._processMap = {}
-    self._processMap["getConfigValue"] = Processor.process_getConfigValue
-    self._processMap["setConfigValue"] = Processor.process_setConfigValue
-    self._processMap["getConfig"] = Processor.process_getConfig
-    self._processMap["getPluginConfig"] = Processor.process_getPluginConfig
-    self._processMap["pauseServer"] = Processor.process_pauseServer
-    self._processMap["unpauseServer"] = Processor.process_unpauseServer
-    self._processMap["togglePause"] = Processor.process_togglePause
-    self._processMap["statusServer"] = Processor.process_statusServer
-    self._processMap["freeSpace"] = Processor.process_freeSpace
-    self._processMap["getServerVersion"] = Processor.process_getServerVersion
-    self._processMap["kill"] = Processor.process_kill
-    self._processMap["restart"] = Processor.process_restart
-    self._processMap["getLog"] = Processor.process_getLog
-    self._processMap["isTimeDownload"] = Processor.process_isTimeDownload
-    self._processMap["isTimeReconnect"] = Processor.process_isTimeReconnect
-    self._processMap["toggleReconnect"] = Processor.process_toggleReconnect
-    self._processMap["generatePackages"] = Processor.process_generatePackages
-    self._processMap["checkURLs"] = Processor.process_checkURLs
-    self._processMap["parseURLs"] = Processor.process_parseURLs
-    self._processMap["checkOnlineStatus"] = Processor.process_checkOnlineStatus
-    self._processMap["checkOnlineStatusContainer"] = Processor.process_checkOnlineStatusContainer
-    self._processMap["pollResults"] = Processor.process_pollResults
-    self._processMap["statusDownloads"] = Processor.process_statusDownloads
-    self._processMap["getPackageData"] = Processor.process_getPackageData
-    self._processMap["getPackageInfo"] = Processor.process_getPackageInfo
-    self._processMap["getFileData"] = Processor.process_getFileData
-    self._processMap["getQueue"] = Processor.process_getQueue
-    self._processMap["getCollector"] = Processor.process_getCollector
-    self._processMap["getQueueData"] = Processor.process_getQueueData
-    self._processMap["getCollectorData"] = Processor.process_getCollectorData
-    self._processMap["getPackageOrder"] = Processor.process_getPackageOrder
-    self._processMap["getFileOrder"] = Processor.process_getFileOrder
-    self._processMap["generateAndAddPackages"] = Processor.process_generateAndAddPackages
-    self._processMap["addPackage"] = Processor.process_addPackage
-    self._processMap["addFiles"] = Processor.process_addFiles
-    self._processMap["uploadContainer"] = Processor.process_uploadContainer
-    self._processMap["deleteFiles"] = Processor.process_deleteFiles
-    self._processMap["deletePackages"] = Processor.process_deletePackages
-    self._processMap["pushToQueue"] = Processor.process_pushToQueue
-    self._processMap["pullFromQueue"] = Processor.process_pullFromQueue
-    self._processMap["restartPackage"] = Processor.process_restartPackage
-    self._processMap["restartFile"] = Processor.process_restartFile
-    self._processMap["recheckPackage"] = Processor.process_recheckPackage
-    self._processMap["stopAllDownloads"] = Processor.process_stopAllDownloads
-    self._processMap["stopDownloads"] = Processor.process_stopDownloads
-    self._processMap["setPackageName"] = Processor.process_setPackageName
-    self._processMap["movePackage"] = Processor.process_movePackage
-    self._processMap["moveFiles"] = Processor.process_moveFiles
-    self._processMap["orderPackage"] = Processor.process_orderPackage
-    self._processMap["orderFile"] = Processor.process_orderFile
-    self._processMap["setPackageData"] = Processor.process_setPackageData
-    self._processMap["deleteFinished"] = Processor.process_deleteFinished
-    self._processMap["restartFailed"] = Processor.process_restartFailed
-    self._processMap["getEvents"] = Processor.process_getEvents
-    self._processMap["getAccounts"] = Processor.process_getAccounts
-    self._processMap["getAccountTypes"] = Processor.process_getAccountTypes
-    self._processMap["updateAccount"] = Processor.process_updateAccount
-    self._processMap["removeAccount"] = Processor.process_removeAccount
-    self._processMap["login"] = Processor.process_login
-    self._processMap["getUserData"] = Processor.process_getUserData
-    self._processMap["getAllUserData"] = Processor.process_getAllUserData
-    self._processMap["getServices"] = Processor.process_getServices
-    self._processMap["hasService"] = Processor.process_hasService
-    self._processMap["call"] = Processor.process_call
-    self._processMap["getAllInfo"] = Processor.process_getAllInfo
-    self._processMap["getInfoByPlugin"] = Processor.process_getInfoByPlugin
-    self._processMap["isCaptchaWaiting"] = Processor.process_isCaptchaWaiting
-    self._processMap["getCaptchaTask"] = Processor.process_getCaptchaTask
-    self._processMap["getCaptchaTaskStatus"] = Processor.process_getCaptchaTaskStatus
-    self._processMap["setCaptchaResult"] = Processor.process_setCaptchaResult
-
-  def process(self, iprot, oprot):
-    (name, type, seqid) = iprot.readMessageBegin()
-    if name not in self._processMap:
-      iprot.skip(TType.STRUCT)
-      iprot.readMessageEnd()
-      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
-      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
-      x.write(oprot)
-      oprot.writeMessageEnd()
-      oprot.trans.flush()
-      return
-    else:
-      self._processMap[name](self, seqid, iprot, oprot)
-    return True
-
-  def process_getConfigValue(self, seqid, iprot, oprot):
-    args = getConfigValue_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getConfigValue_result()
-    result.success = self._handler.getConfigValue(args.category, args.option, args.section)
-    oprot.writeMessageBegin("getConfigValue", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_setConfigValue(self, seqid, iprot, oprot):
-    args = setConfigValue_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = setConfigValue_result()
-    self._handler.setConfigValue(args.category, args.option, args.value, args.section)
-    oprot.writeMessageBegin("setConfigValue", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_getConfig(self, seqid, iprot, oprot):
-    args = getConfig_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getConfig_result()
-    result.success = self._handler.getConfig()
-    oprot.writeMessageBegin("getConfig", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_getPluginConfig(self, seqid, iprot, oprot):
-    args = getPluginConfig_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getPluginConfig_result()
-    result.success = self._handler.getPluginConfig()
-    oprot.writeMessageBegin("getPluginConfig", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_pauseServer(self, seqid, iprot, oprot):
-    args = pauseServer_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = pauseServer_result()
-    self._handler.pauseServer()
-    oprot.writeMessageBegin("pauseServer", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_unpauseServer(self, seqid, iprot, oprot):
-    args = unpauseServer_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = unpauseServer_result()
-    self._handler.unpauseServer()
-    oprot.writeMessageBegin("unpauseServer", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_togglePause(self, seqid, iprot, oprot):
-    args = togglePause_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = togglePause_result()
-    result.success = self._handler.togglePause()
-    oprot.writeMessageBegin("togglePause", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_statusServer(self, seqid, iprot, oprot):
-    args = statusServer_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = statusServer_result()
-    result.success = self._handler.statusServer()
-    oprot.writeMessageBegin("statusServer", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_freeSpace(self, seqid, iprot, oprot):
-    args = freeSpace_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = freeSpace_result()
-    result.success = self._handler.freeSpace()
-    oprot.writeMessageBegin("freeSpace", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_getServerVersion(self, seqid, iprot, oprot):
-    args = getServerVersion_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getServerVersion_result()
-    result.success = self._handler.getServerVersion()
-    oprot.writeMessageBegin("getServerVersion", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_kill(self, seqid, iprot, oprot):
-    args = kill_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = kill_result()
-    self._handler.kill()
-    oprot.writeMessageBegin("kill", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_restart(self, seqid, iprot, oprot):
-    args = restart_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = restart_result()
-    self._handler.restart()
-    oprot.writeMessageBegin("restart", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_getLog(self, seqid, iprot, oprot):
-    args = getLog_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getLog_result()
-    result.success = self._handler.getLog(args.offset)
-    oprot.writeMessageBegin("getLog", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_isTimeDownload(self, seqid, iprot, oprot):
-    args = isTimeDownload_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = isTimeDownload_result()
-    result.success = self._handler.isTimeDownload()
-    oprot.writeMessageBegin("isTimeDownload", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_isTimeReconnect(self, seqid, iprot, oprot):
-    args = isTimeReconnect_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = isTimeReconnect_result()
-    result.success = self._handler.isTimeReconnect()
-    oprot.writeMessageBegin("isTimeReconnect", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_toggleReconnect(self, seqid, iprot, oprot):
-    args = toggleReconnect_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = toggleReconnect_result()
-    result.success = self._handler.toggleReconnect()
-    oprot.writeMessageBegin("toggleReconnect", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_generatePackages(self, seqid, iprot, oprot):
-    args = generatePackages_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = generatePackages_result()
-    result.success = self._handler.generatePackages(args.links)
-    oprot.writeMessageBegin("generatePackages", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_checkURLs(self, seqid, iprot, oprot):
-    args = checkURLs_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = checkURLs_result()
-    result.success = self._handler.checkURLs(args.urls)
-    oprot.writeMessageBegin("checkURLs", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_parseURLs(self, seqid, iprot, oprot):
-    args = parseURLs_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = parseURLs_result()
-    result.success = self._handler.parseURLs(args.html, args.url)
-    oprot.writeMessageBegin("parseURLs", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_checkOnlineStatus(self, seqid, iprot, oprot):
-    args = checkOnlineStatus_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = checkOnlineStatus_result()
-    result.success = self._handler.checkOnlineStatus(args.urls)
-    oprot.writeMessageBegin("checkOnlineStatus", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_checkOnlineStatusContainer(self, seqid, iprot, oprot):
-    args = checkOnlineStatusContainer_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = checkOnlineStatusContainer_result()
-    result.success = self._handler.checkOnlineStatusContainer(args.urls, args.filename, args.data)
-    oprot.writeMessageBegin("checkOnlineStatusContainer", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_pollResults(self, seqid, iprot, oprot):
-    args = pollResults_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = pollResults_result()
-    result.success = self._handler.pollResults(args.rid)
-    oprot.writeMessageBegin("pollResults", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_statusDownloads(self, seqid, iprot, oprot):
-    args = statusDownloads_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = statusDownloads_result()
-    result.success = self._handler.statusDownloads()
-    oprot.writeMessageBegin("statusDownloads", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_getPackageData(self, seqid, iprot, oprot):
-    args = getPackageData_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getPackageData_result()
-    try:
-      result.success = self._handler.getPackageData(args.pid)
-    except PackageDoesNotExists, e:
-      result.e = e
-    oprot.writeMessageBegin("getPackageData", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_getPackageInfo(self, seqid, iprot, oprot):
-    args = getPackageInfo_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getPackageInfo_result()
-    try:
-      result.success = self._handler.getPackageInfo(args.pid)
-    except PackageDoesNotExists, e:
-      result.e = e
-    oprot.writeMessageBegin("getPackageInfo", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_getFileData(self, seqid, iprot, oprot):
-    args = getFileData_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getFileData_result()
-    try:
-      result.success = self._handler.getFileData(args.fid)
-    except FileDoesNotExists, e:
-      result.e = e
-    oprot.writeMessageBegin("getFileData", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_getQueue(self, seqid, iprot, oprot):
-    args = getQueue_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getQueue_result()
-    result.success = self._handler.getQueue()
-    oprot.writeMessageBegin("getQueue", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_getCollector(self, seqid, iprot, oprot):
-    args = getCollector_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getCollector_result()
-    result.success = self._handler.getCollector()
-    oprot.writeMessageBegin("getCollector", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_getQueueData(self, seqid, iprot, oprot):
-    args = getQueueData_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getQueueData_result()
-    result.success = self._handler.getQueueData()
-    oprot.writeMessageBegin("getQueueData", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_getCollectorData(self, seqid, iprot, oprot):
-    args = getCollectorData_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getCollectorData_result()
-    result.success = self._handler.getCollectorData()
-    oprot.writeMessageBegin("getCollectorData", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_getPackageOrder(self, seqid, iprot, oprot):
-    args = getPackageOrder_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getPackageOrder_result()
-    result.success = self._handler.getPackageOrder(args.destination)
-    oprot.writeMessageBegin("getPackageOrder", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_getFileOrder(self, seqid, iprot, oprot):
-    args = getFileOrder_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getFileOrder_result()
-    result.success = self._handler.getFileOrder(args.pid)
-    oprot.writeMessageBegin("getFileOrder", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_generateAndAddPackages(self, seqid, iprot, oprot):
-    args = generateAndAddPackages_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = generateAndAddPackages_result()
-    result.success = self._handler.generateAndAddPackages(args.links, args.dest)
-    oprot.writeMessageBegin("generateAndAddPackages", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_addPackage(self, seqid, iprot, oprot):
-    args = addPackage_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = addPackage_result()
-    result.success = self._handler.addPackage(args.name, args.links, args.dest)
-    oprot.writeMessageBegin("addPackage", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_addFiles(self, seqid, iprot, oprot):
-    args = addFiles_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = addFiles_result()
-    self._handler.addFiles(args.pid, args.links)
-    oprot.writeMessageBegin("addFiles", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_uploadContainer(self, seqid, iprot, oprot):
-    args = uploadContainer_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = uploadContainer_result()
-    self._handler.uploadContainer(args.filename, args.data)
-    oprot.writeMessageBegin("uploadContainer", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_deleteFiles(self, seqid, iprot, oprot):
-    args = deleteFiles_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = deleteFiles_result()
-    self._handler.deleteFiles(args.fids)
-    oprot.writeMessageBegin("deleteFiles", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_deletePackages(self, seqid, iprot, oprot):
-    args = deletePackages_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = deletePackages_result()
-    self._handler.deletePackages(args.pids)
-    oprot.writeMessageBegin("deletePackages", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_pushToQueue(self, seqid, iprot, oprot):
-    args = pushToQueue_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = pushToQueue_result()
-    self._handler.pushToQueue(args.pid)
-    oprot.writeMessageBegin("pushToQueue", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_pullFromQueue(self, seqid, iprot, oprot):
-    args = pullFromQueue_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = pullFromQueue_result()
-    self._handler.pullFromQueue(args.pid)
-    oprot.writeMessageBegin("pullFromQueue", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_restartPackage(self, seqid, iprot, oprot):
-    args = restartPackage_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = restartPackage_result()
-    self._handler.restartPackage(args.pid)
-    oprot.writeMessageBegin("restartPackage", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_restartFile(self, seqid, iprot, oprot):
-    args = restartFile_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = restartFile_result()
-    self._handler.restartFile(args.fid)
-    oprot.writeMessageBegin("restartFile", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_recheckPackage(self, seqid, iprot, oprot):
-    args = recheckPackage_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = recheckPackage_result()
-    self._handler.recheckPackage(args.pid)
-    oprot.writeMessageBegin("recheckPackage", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_stopAllDownloads(self, seqid, iprot, oprot):
-    args = stopAllDownloads_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = stopAllDownloads_result()
-    self._handler.stopAllDownloads()
-    oprot.writeMessageBegin("stopAllDownloads", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_stopDownloads(self, seqid, iprot, oprot):
-    args = stopDownloads_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = stopDownloads_result()
-    self._handler.stopDownloads(args.fids)
-    oprot.writeMessageBegin("stopDownloads", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_setPackageName(self, seqid, iprot, oprot):
-    args = setPackageName_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = setPackageName_result()
-    self._handler.setPackageName(args.pid, args.name)
-    oprot.writeMessageBegin("setPackageName", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_movePackage(self, seqid, iprot, oprot):
-    args = movePackage_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = movePackage_result()
-    self._handler.movePackage(args.destination, args.pid)
-    oprot.writeMessageBegin("movePackage", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_moveFiles(self, seqid, iprot, oprot):
-    args = moveFiles_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = moveFiles_result()
-    self._handler.moveFiles(args.fids, args.pid)
-    oprot.writeMessageBegin("moveFiles", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_orderPackage(self, seqid, iprot, oprot):
-    args = orderPackage_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = orderPackage_result()
-    self._handler.orderPackage(args.pid, args.position)
-    oprot.writeMessageBegin("orderPackage", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_orderFile(self, seqid, iprot, oprot):
-    args = orderFile_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = orderFile_result()
-    self._handler.orderFile(args.fid, args.position)
-    oprot.writeMessageBegin("orderFile", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_setPackageData(self, seqid, iprot, oprot):
-    args = setPackageData_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = setPackageData_result()
-    try:
-      self._handler.setPackageData(args.pid, args.data)
-    except PackageDoesNotExists, e:
-      result.e = e
-    oprot.writeMessageBegin("setPackageData", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_deleteFinished(self, seqid, iprot, oprot):
-    args = deleteFinished_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = deleteFinished_result()
-    result.success = self._handler.deleteFinished()
-    oprot.writeMessageBegin("deleteFinished", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_restartFailed(self, seqid, iprot, oprot):
-    args = restartFailed_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = restartFailed_result()
-    self._handler.restartFailed()
-    oprot.writeMessageBegin("restartFailed", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_getEvents(self, seqid, iprot, oprot):
-    args = getEvents_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getEvents_result()
-    result.success = self._handler.getEvents(args.uuid)
-    oprot.writeMessageBegin("getEvents", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_getAccounts(self, seqid, iprot, oprot):
-    args = getAccounts_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getAccounts_result()
-    result.success = self._handler.getAccounts(args.refresh)
-    oprot.writeMessageBegin("getAccounts", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_getAccountTypes(self, seqid, iprot, oprot):
-    args = getAccountTypes_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getAccountTypes_result()
-    result.success = self._handler.getAccountTypes()
-    oprot.writeMessageBegin("getAccountTypes", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_updateAccount(self, seqid, iprot, oprot):
-    args = updateAccount_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = updateAccount_result()
-    self._handler.updateAccount(args.plugin, args.account, args.password, args.options)
-    oprot.writeMessageBegin("updateAccount", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_removeAccount(self, seqid, iprot, oprot):
-    args = removeAccount_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = removeAccount_result()
-    self._handler.removeAccount(args.plugin, args.account)
-    oprot.writeMessageBegin("removeAccount", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_login(self, seqid, iprot, oprot):
-    args = login_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = login_result()
-    result.success = self._handler.login(args.username, args.password)
-    oprot.writeMessageBegin("login", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_getUserData(self, seqid, iprot, oprot):
-    args = getUserData_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getUserData_result()
-    result.success = self._handler.getUserData(args.username, args.password)
-    oprot.writeMessageBegin("getUserData", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_getAllUserData(self, seqid, iprot, oprot):
-    args = getAllUserData_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getAllUserData_result()
-    result.success = self._handler.getAllUserData()
-    oprot.writeMessageBegin("getAllUserData", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_getServices(self, seqid, iprot, oprot):
-    args = getServices_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getServices_result()
-    result.success = self._handler.getServices()
-    oprot.writeMessageBegin("getServices", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_hasService(self, seqid, iprot, oprot):
-    args = hasService_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = hasService_result()
-    result.success = self._handler.hasService(args.plugin, args.func)
-    oprot.writeMessageBegin("hasService", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_call(self, seqid, iprot, oprot):
-    args = call_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = call_result()
-    try:
-      result.success = self._handler.call(args.info)
-    except ServiceDoesNotExists, ex:
-      result.ex = ex
-    except ServiceException, e:
-      result.e = e
-    oprot.writeMessageBegin("call", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_getAllInfo(self, seqid, iprot, oprot):
-    args = getAllInfo_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getAllInfo_result()
-    result.success = self._handler.getAllInfo()
-    oprot.writeMessageBegin("getAllInfo", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_getInfoByPlugin(self, seqid, iprot, oprot):
-    args = getInfoByPlugin_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getInfoByPlugin_result()
-    result.success = self._handler.getInfoByPlugin(args.plugin)
-    oprot.writeMessageBegin("getInfoByPlugin", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_isCaptchaWaiting(self, seqid, iprot, oprot):
-    args = isCaptchaWaiting_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = isCaptchaWaiting_result()
-    result.success = self._handler.isCaptchaWaiting()
-    oprot.writeMessageBegin("isCaptchaWaiting", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_getCaptchaTask(self, seqid, iprot, oprot):
-    args = getCaptchaTask_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getCaptchaTask_result()
-    result.success = self._handler.getCaptchaTask(args.exclusive)
-    oprot.writeMessageBegin("getCaptchaTask", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_getCaptchaTaskStatus(self, seqid, iprot, oprot):
-    args = getCaptchaTaskStatus_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getCaptchaTaskStatus_result()
-    result.success = self._handler.getCaptchaTaskStatus(args.tid)
-    oprot.writeMessageBegin("getCaptchaTaskStatus", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_setCaptchaResult(self, seqid, iprot, oprot):
-    args = setCaptchaResult_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = setCaptchaResult_result()
-    self._handler.setCaptchaResult(args.tid, args.result)
-    oprot.writeMessageBegin("setCaptchaResult", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-
-# HELPER FUNCTIONS AND STRUCTURES
-
-class getConfigValue_args(TBase):
-  """
-  Attributes:
-   - category
-   - option
-   - section
-  """
-
-  __slots__ = [ 
-    'category',
-    'option',
-    'section',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.STRING, 'category', None, None, ), # 1
-    (2, TType.STRING, 'option', None, None, ), # 2
-    (3, TType.STRING, 'section', None, None, ), # 3
-  )
-
-  def __init__(self, category=None, option=None, section=None,):
-    self.category = category
-    self.option = option
-    self.section = section
-
-
-class getConfigValue_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.STRING, 'success', None, None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class setConfigValue_args(TBase):
-  """
-  Attributes:
-   - category
-   - option
-   - value
-   - section
-  """
-
-  __slots__ = [ 
-    'category',
-    'option',
-    'value',
-    'section',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.STRING, 'category', None, None, ), # 1
-    (2, TType.STRING, 'option', None, None, ), # 2
-    (3, TType.STRING, 'value', None, None, ), # 3
-    (4, TType.STRING, 'section', None, None, ), # 4
-  )
-
-  def __init__(self, category=None, option=None, value=None, section=None,):
-    self.category = category
-    self.option = option
-    self.value = value
-    self.section = section
-
-
-class setConfigValue_result(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class getConfig_args(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class getConfig_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(ConfigSection, ConfigSection.thrift_spec)), None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class getPluginConfig_args(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class getPluginConfig_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(ConfigSection, ConfigSection.thrift_spec)), None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class pauseServer_args(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class pauseServer_result(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class unpauseServer_args(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class unpauseServer_result(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class togglePause_args(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class togglePause_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.BOOL, 'success', None, None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class statusServer_args(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class statusServer_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.STRUCT, 'success', (ServerStatus, ServerStatus.thrift_spec), None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class freeSpace_args(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class freeSpace_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.I64, 'success', None, None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class getServerVersion_args(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class getServerVersion_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.STRING, 'success', None, None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class kill_args(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class kill_result(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class restart_args(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class restart_result(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class getLog_args(TBase):
-  """
-  Attributes:
-   - offset
-  """
-
-  __slots__ = [ 
-    'offset',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.I32, 'offset', None, None, ), # 1
-  )
-
-  def __init__(self, offset=None,):
-    self.offset = offset
-
-
-class getLog_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class isTimeDownload_args(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class isTimeDownload_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.BOOL, 'success', None, None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class isTimeReconnect_args(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class isTimeReconnect_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.BOOL, 'success', None, None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class toggleReconnect_args(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class toggleReconnect_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.BOOL, 'success', None, None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class generatePackages_args(TBase):
-  """
-  Attributes:
-   - links
-  """
-
-  __slots__ = [ 
-    'links',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.LIST, 'links', (TType.STRING,None), None, ), # 1
-  )
-
-  def __init__(self, links=None,):
-    self.links = links
-
-
-class generatePackages_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRING,None)), None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class checkURLs_args(TBase):
-  """
-  Attributes:
-   - urls
-  """
-
-  __slots__ = [ 
-    'urls',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.LIST, 'urls', (TType.STRING,None), None, ), # 1
-  )
-
-  def __init__(self, urls=None,):
-    self.urls = urls
-
-
-class checkURLs_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRING,None)), None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class parseURLs_args(TBase):
-  """
-  Attributes:
-   - html
-   - url
-  """
-
-  __slots__ = [ 
-    'html',
-    'url',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.STRING, 'html', None, None, ), # 1
-    (2, TType.STRING, 'url', None, None, ), # 2
-  )
-
-  def __init__(self, html=None, url=None,):
-    self.html = html
-    self.url = url
-
-
-class parseURLs_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRING,None)), None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class checkOnlineStatus_args(TBase):
-  """
-  Attributes:
-   - urls
-  """
-
-  __slots__ = [ 
-    'urls',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.LIST, 'urls', (TType.STRING,None), None, ), # 1
-  )
-
-  def __init__(self, urls=None,):
-    self.urls = urls
-
-
-class checkOnlineStatus_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.STRUCT, 'success', (OnlineCheck, OnlineCheck.thrift_spec), None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class checkOnlineStatusContainer_args(TBase):
-  """
-  Attributes:
-   - urls
-   - filename
-   - data
-  """
-
-  __slots__ = [ 
-    'urls',
-    'filename',
-    'data',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.LIST, 'urls', (TType.STRING,None), None, ), # 1
-    (2, TType.STRING, 'filename', None, None, ), # 2
-    (3, TType.STRING, 'data', None, None, ), # 3
-  )
-
-  def __init__(self, urls=None, filename=None, data=None,):
-    self.urls = urls
-    self.filename = filename
-    self.data = data
-
-
-class checkOnlineStatusContainer_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.STRUCT, 'success', (OnlineCheck, OnlineCheck.thrift_spec), None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class pollResults_args(TBase):
-  """
-  Attributes:
-   - rid
-  """
-
-  __slots__ = [ 
-    'rid',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.I32, 'rid', None, None, ), # 1
-  )
-
-  def __init__(self, rid=None,):
-    self.rid = rid
-
-
-class pollResults_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.STRUCT, 'success', (OnlineCheck, OnlineCheck.thrift_spec), None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class statusDownloads_args(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class statusDownloads_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.LIST, 'success', (TType.STRUCT,(DownloadInfo, DownloadInfo.thrift_spec)), None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class getPackageData_args(TBase):
-  """
-  Attributes:
-   - pid
-  """
-
-  __slots__ = [ 
-    'pid',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.I32, 'pid', None, None, ), # 1
-  )
-
-  def __init__(self, pid=None,):
-    self.pid = pid
-
-
-class getPackageData_result(TBase):
-  """
-  Attributes:
-   - success
-   - e
-  """
-
-  __slots__ = [ 
-    'success',
-    'e',
-   ]
-
-  thrift_spec = (
-    (0, TType.STRUCT, 'success', (PackageData, PackageData.thrift_spec), None, ), # 0
-    (1, TType.STRUCT, 'e', (PackageDoesNotExists, PackageDoesNotExists.thrift_spec), None, ), # 1
-  )
-
-  def __init__(self, success=None, e=None,):
-    self.success = success
-    self.e = e
-
-
-class getPackageInfo_args(TBase):
-  """
-  Attributes:
-   - pid
-  """
-
-  __slots__ = [ 
-    'pid',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.I32, 'pid', None, None, ), # 1
-  )
-
-  def __init__(self, pid=None,):
-    self.pid = pid
-
-
-class getPackageInfo_result(TBase):
-  """
-  Attributes:
-   - success
-   - e
-  """
-
-  __slots__ = [ 
-    'success',
-    'e',
-   ]
-
-  thrift_spec = (
-    (0, TType.STRUCT, 'success', (PackageData, PackageData.thrift_spec), None, ), # 0
-    (1, TType.STRUCT, 'e', (PackageDoesNotExists, PackageDoesNotExists.thrift_spec), None, ), # 1
-  )
-
-  def __init__(self, success=None, e=None,):
-    self.success = success
-    self.e = e
-
-
-class getFileData_args(TBase):
-  """
-  Attributes:
-   - fid
-  """
-
-  __slots__ = [ 
-    'fid',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.I32, 'fid', None, None, ), # 1
-  )
-
-  def __init__(self, fid=None,):
-    self.fid = fid
-
-
-class getFileData_result(TBase):
-  """
-  Attributes:
-   - success
-   - e
-  """
-
-  __slots__ = [ 
-    'success',
-    'e',
-   ]
-
-  thrift_spec = (
-    (0, TType.STRUCT, 'success', (FileData, FileData.thrift_spec), None, ), # 0
-    (1, TType.STRUCT, 'e', (FileDoesNotExists, FileDoesNotExists.thrift_spec), None, ), # 1
-  )
-
-  def __init__(self, success=None, e=None,):
-    self.success = success
-    self.e = e
-
-
-class getQueue_args(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class getQueue_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.LIST, 'success', (TType.STRUCT,(PackageData, PackageData.thrift_spec)), None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class getCollector_args(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class getCollector_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.LIST, 'success', (TType.STRUCT,(PackageData, PackageData.thrift_spec)), None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class getQueueData_args(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class getQueueData_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.LIST, 'success', (TType.STRUCT,(PackageData, PackageData.thrift_spec)), None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class getCollectorData_args(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class getCollectorData_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.LIST, 'success', (TType.STRUCT,(PackageData, PackageData.thrift_spec)), None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class getPackageOrder_args(TBase):
-  """
-  Attributes:
-   - destination
-  """
-
-  __slots__ = [ 
-    'destination',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.I32, 'destination', None, None, ), # 1
-  )
-
-  def __init__(self, destination=None,):
-    self.destination = destination
-
-
-class getPackageOrder_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.MAP, 'success', (TType.I16,None,TType.I32,None), None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class getFileOrder_args(TBase):
-  """
-  Attributes:
-   - pid
-  """
-
-  __slots__ = [ 
-    'pid',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.I32, 'pid', None, None, ), # 1
-  )
-
-  def __init__(self, pid=None,):
-    self.pid = pid
-
-
-class getFileOrder_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.MAP, 'success', (TType.I16,None,TType.I32,None), None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class generateAndAddPackages_args(TBase):
-  """
-  Attributes:
-   - links
-   - dest
-  """
-
-  __slots__ = [ 
-    'links',
-    'dest',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.LIST, 'links', (TType.STRING,None), None, ), # 1
-    (2, TType.I32, 'dest', None, None, ), # 2
-  )
-
-  def __init__(self, links=None, dest=None,):
-    self.links = links
-    self.dest = dest
-
-
-class generateAndAddPackages_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.LIST, 'success', (TType.I32,None), None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class addPackage_args(TBase):
-  """
-  Attributes:
-   - name
-   - links
-   - dest
-  """
-
-  __slots__ = [ 
-    'name',
-    'links',
-    'dest',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.STRING, 'name', None, None, ), # 1
-    (2, TType.LIST, 'links', (TType.STRING,None), None, ), # 2
-    (3, TType.I32, 'dest', None, None, ), # 3
-  )
-
-  def __init__(self, name=None, links=None, dest=None,):
-    self.name = name
-    self.links = links
-    self.dest = dest
-
-
-class addPackage_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.I32, 'success', None, None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class addFiles_args(TBase):
-  """
-  Attributes:
-   - pid
-   - links
-  """
-
-  __slots__ = [ 
-    'pid',
-    'links',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.I32, 'pid', None, None, ), # 1
-    (2, TType.LIST, 'links', (TType.STRING,None), None, ), # 2
-  )
-
-  def __init__(self, pid=None, links=None,):
-    self.pid = pid
-    self.links = links
-
-
-class addFiles_result(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class uploadContainer_args(TBase):
-  """
-  Attributes:
-   - filename
-   - data
-  """
-
-  __slots__ = [ 
-    'filename',
-    'data',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.STRING, 'filename', None, None, ), # 1
-    (2, TType.STRING, 'data', None, None, ), # 2
-  )
-
-  def __init__(self, filename=None, data=None,):
-    self.filename = filename
-    self.data = data
-
-
-class uploadContainer_result(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class deleteFiles_args(TBase):
-  """
-  Attributes:
-   - fids
-  """
-
-  __slots__ = [ 
-    'fids',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.LIST, 'fids', (TType.I32,None), None, ), # 1
-  )
-
-  def __init__(self, fids=None,):
-    self.fids = fids
-
-
-class deleteFiles_result(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class deletePackages_args(TBase):
-  """
-  Attributes:
-   - pids
-  """
-
-  __slots__ = [ 
-    'pids',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.LIST, 'pids', (TType.I32,None), None, ), # 1
-  )
-
-  def __init__(self, pids=None,):
-    self.pids = pids
-
-
-class deletePackages_result(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class pushToQueue_args(TBase):
-  """
-  Attributes:
-   - pid
-  """
-
-  __slots__ = [ 
-    'pid',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.I32, 'pid', None, None, ), # 1
-  )
-
-  def __init__(self, pid=None,):
-    self.pid = pid
-
-
-class pushToQueue_result(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class pullFromQueue_args(TBase):
-  """
-  Attributes:
-   - pid
-  """
-
-  __slots__ = [ 
-    'pid',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.I32, 'pid', None, None, ), # 1
-  )
-
-  def __init__(self, pid=None,):
-    self.pid = pid
-
-
-class pullFromQueue_result(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class restartPackage_args(TBase):
-  """
-  Attributes:
-   - pid
-  """
-
-  __slots__ = [ 
-    'pid',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.I32, 'pid', None, None, ), # 1
-  )
-
-  def __init__(self, pid=None,):
-    self.pid = pid
-
-
-class restartPackage_result(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class restartFile_args(TBase):
-  """
-  Attributes:
-   - fid
-  """
-
-  __slots__ = [ 
-    'fid',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.I32, 'fid', None, None, ), # 1
-  )
-
-  def __init__(self, fid=None,):
-    self.fid = fid
-
-
-class restartFile_result(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class recheckPackage_args(TBase):
-  """
-  Attributes:
-   - pid
-  """
-
-  __slots__ = [ 
-    'pid',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.I32, 'pid', None, None, ), # 1
-  )
-
-  def __init__(self, pid=None,):
-    self.pid = pid
-
-
-class recheckPackage_result(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class stopAllDownloads_args(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class stopAllDownloads_result(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class stopDownloads_args(TBase):
-  """
-  Attributes:
-   - fids
-  """
-
-  __slots__ = [ 
-    'fids',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.LIST, 'fids', (TType.I32,None), None, ), # 1
-  )
-
-  def __init__(self, fids=None,):
-    self.fids = fids
-
-
-class stopDownloads_result(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class setPackageName_args(TBase):
-  """
-  Attributes:
-   - pid
-   - name
-  """
-
-  __slots__ = [ 
-    'pid',
-    'name',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.I32, 'pid', None, None, ), # 1
-    (2, TType.STRING, 'name', None, None, ), # 2
-  )
-
-  def __init__(self, pid=None, name=None,):
-    self.pid = pid
-    self.name = name
-
-
-class setPackageName_result(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class movePackage_args(TBase):
-  """
-  Attributes:
-   - destination
-   - pid
-  """
-
-  __slots__ = [ 
-    'destination',
-    'pid',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.I32, 'destination', None, None, ), # 1
-    (2, TType.I32, 'pid', None, None, ), # 2
-  )
-
-  def __init__(self, destination=None, pid=None,):
-    self.destination = destination
-    self.pid = pid
-
-
-class movePackage_result(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class moveFiles_args(TBase):
-  """
-  Attributes:
-   - fids
-   - pid
-  """
-
-  __slots__ = [ 
-    'fids',
-    'pid',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.LIST, 'fids', (TType.I32,None), None, ), # 1
-    (2, TType.I32, 'pid', None, None, ), # 2
-  )
-
-  def __init__(self, fids=None, pid=None,):
-    self.fids = fids
-    self.pid = pid
-
-
-class moveFiles_result(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class orderPackage_args(TBase):
-  """
-  Attributes:
-   - pid
-   - position
-  """
-
-  __slots__ = [ 
-    'pid',
-    'position',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.I32, 'pid', None, None, ), # 1
-    (2, TType.I16, 'position', None, None, ), # 2
-  )
-
-  def __init__(self, pid=None, position=None,):
-    self.pid = pid
-    self.position = position
-
-
-class orderPackage_result(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class orderFile_args(TBase):
-  """
-  Attributes:
-   - fid
-   - position
-  """
-
-  __slots__ = [ 
-    'fid',
-    'position',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.I32, 'fid', None, None, ), # 1
-    (2, TType.I16, 'position', None, None, ), # 2
-  )
-
-  def __init__(self, fid=None, position=None,):
-    self.fid = fid
-    self.position = position
-
-
-class orderFile_result(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class setPackageData_args(TBase):
-  """
-  Attributes:
-   - pid
-   - data
-  """
-
-  __slots__ = [ 
-    'pid',
-    'data',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.I32, 'pid', None, None, ), # 1
-    (2, TType.MAP, 'data', (TType.STRING,None,TType.STRING,None), None, ), # 2
-  )
-
-  def __init__(self, pid=None, data=None,):
-    self.pid = pid
-    self.data = data
-
-
-class setPackageData_result(TBase):
-  """
-  Attributes:
-   - e
-  """
-
-  __slots__ = [ 
-    'e',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.STRUCT, 'e', (PackageDoesNotExists, PackageDoesNotExists.thrift_spec), None, ), # 1
-  )
-
-  def __init__(self, e=None,):
-    self.e = e
-
-
-class deleteFinished_args(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class deleteFinished_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.LIST, 'success', (TType.I32,None), None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class restartFailed_args(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class restartFailed_result(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class getEvents_args(TBase):
-  """
-  Attributes:
-   - uuid
-  """
-
-  __slots__ = [ 
-    'uuid',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.STRING, 'uuid', None, None, ), # 1
-  )
-
-  def __init__(self, uuid=None,):
-    self.uuid = uuid
-
-
-class getEvents_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.LIST, 'success', (TType.STRUCT,(EventInfo, EventInfo.thrift_spec)), None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class getAccounts_args(TBase):
-  """
-  Attributes:
-   - refresh
-  """
-
-  __slots__ = [ 
-    'refresh',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.BOOL, 'refresh', None, None, ), # 1
-  )
-
-  def __init__(self, refresh=None,):
-    self.refresh = refresh
-
-
-class getAccounts_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.LIST, 'success', (TType.STRUCT,(AccountInfo, AccountInfo.thrift_spec)), None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class getAccountTypes_args(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class getAccountTypes_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class updateAccount_args(TBase):
-  """
-  Attributes:
-   - plugin
-   - account
-   - password
-   - options
-  """
-
-  __slots__ = [ 
-    'plugin',
-    'account',
-    'password',
-    'options',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.STRING, 'plugin', None, None, ), # 1
-    (2, TType.STRING, 'account', None, None, ), # 2
-    (3, TType.STRING, 'password', None, None, ), # 3
-    (4, TType.MAP, 'options', (TType.STRING,None,TType.STRING,None), None, ), # 4
-  )
-
-  def __init__(self, plugin=None, account=None, password=None, options=None,):
-    self.plugin = plugin
-    self.account = account
-    self.password = password
-    self.options = options
-
-
-class updateAccount_result(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class removeAccount_args(TBase):
-  """
-  Attributes:
-   - plugin
-   - account
-  """
-
-  __slots__ = [ 
-    'plugin',
-    'account',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.STRING, 'plugin', None, None, ), # 1
-    (2, TType.STRING, 'account', None, None, ), # 2
-  )
-
-  def __init__(self, plugin=None, account=None,):
-    self.plugin = plugin
-    self.account = account
-
-
-class removeAccount_result(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class login_args(TBase):
-  """
-  Attributes:
-   - username
-   - password
-  """
-
-  __slots__ = [ 
-    'username',
-    'password',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.STRING, 'username', None, None, ), # 1
-    (2, TType.STRING, 'password', None, None, ), # 2
-  )
-
-  def __init__(self, username=None, password=None,):
-    self.username = username
-    self.password = password
-
-
-class login_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.BOOL, 'success', None, None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class getUserData_args(TBase):
-  """
-  Attributes:
-   - username
-   - password
-  """
-
-  __slots__ = [ 
-    'username',
-    'password',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.STRING, 'username', None, None, ), # 1
-    (2, TType.STRING, 'password', None, None, ), # 2
-  )
-
-  def __init__(self, username=None, password=None,):
-    self.username = username
-    self.password = password
-
-
-class getUserData_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.STRUCT, 'success', (UserData, UserData.thrift_spec), None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class getAllUserData_args(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class getAllUserData_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(UserData, UserData.thrift_spec)), None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class getServices_args(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class getServices_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.MAP, 'success', (TType.STRING,None,TType.MAP,(TType.STRING,None,TType.STRING,None)), None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class hasService_args(TBase):
-  """
-  Attributes:
-   - plugin
-   - func
-  """
-
-  __slots__ = [ 
-    'plugin',
-    'func',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.STRING, 'plugin', None, None, ), # 1
-    (2, TType.STRING, 'func', None, None, ), # 2
-  )
-
-  def __init__(self, plugin=None, func=None,):
-    self.plugin = plugin
-    self.func = func
-
-
-class hasService_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.BOOL, 'success', None, None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class call_args(TBase):
-  """
-  Attributes:
-   - info
-  """
-
-  __slots__ = [ 
-    'info',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.STRUCT, 'info', (ServiceCall, ServiceCall.thrift_spec), None, ), # 1
-  )
-
-  def __init__(self, info=None,):
-    self.info = info
-
-
-class call_result(TBase):
-  """
-  Attributes:
-   - success
-   - ex
-   - e
-  """
-
-  __slots__ = [ 
-    'success',
-    'ex',
-    'e',
-   ]
-
-  thrift_spec = (
-    (0, TType.STRING, 'success', None, None, ), # 0
-    (1, TType.STRUCT, 'ex', (ServiceDoesNotExists, ServiceDoesNotExists.thrift_spec), None, ), # 1
-    (2, TType.STRUCT, 'e', (ServiceException, ServiceException.thrift_spec), None, ), # 2
-  )
-
-  def __init__(self, success=None, ex=None, e=None,):
-    self.success = success
-    self.ex = ex
-    self.e = e
-
-
-class getAllInfo_args(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class getAllInfo_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.MAP, 'success', (TType.STRING,None,TType.MAP,(TType.STRING,None,TType.STRING,None)), None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class getInfoByPlugin_args(TBase):
-  """
-  Attributes:
-   - plugin
-  """
-
-  __slots__ = [ 
-    'plugin',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.STRING, 'plugin', None, None, ), # 1
-  )
-
-  def __init__(self, plugin=None,):
-    self.plugin = plugin
-
-
-class getInfoByPlugin_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class isCaptchaWaiting_args(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
-
-class isCaptchaWaiting_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.BOOL, 'success', None, None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class getCaptchaTask_args(TBase):
-  """
-  Attributes:
-   - exclusive
-  """
-
-  __slots__ = [ 
-    'exclusive',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.BOOL, 'exclusive', None, None, ), # 1
-  )
-
-  def __init__(self, exclusive=None,):
-    self.exclusive = exclusive
-
-
-class getCaptchaTask_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.STRUCT, 'success', (CaptchaTask, CaptchaTask.thrift_spec), None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class getCaptchaTaskStatus_args(TBase):
-  """
-  Attributes:
-   - tid
-  """
-
-  __slots__ = [ 
-    'tid',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.I32, 'tid', None, None, ), # 1
-  )
-
-  def __init__(self, tid=None,):
-    self.tid = tid
-
-
-class getCaptchaTaskStatus_result(TBase):
-  """
-  Attributes:
-   - success
-  """
-
-  __slots__ = [ 
-    'success',
-   ]
-
-  thrift_spec = (
-    (0, TType.STRING, 'success', None, None, ), # 0
-  )
-
-  def __init__(self, success=None,):
-    self.success = success
-
-
-class setCaptchaResult_args(TBase):
-  """
-  Attributes:
-   - tid
-   - result
-  """
-
-  __slots__ = [ 
-    'tid',
-    'result',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.I32, 'tid', None, None, ), # 1
-    (2, TType.STRING, 'result', None, None, ), # 2
-  )
-
-  def __init__(self, tid=None, result=None,):
-    self.tid = tid
-    self.result = result
-
-
-class setCaptchaResult_result(TBase):
-
-  __slots__ = [ 
-   ]
-
-  thrift_spec = (
-  )
-
diff --git a/module/remote/thriftbackend/thriftgen/pyload/__init__.py b/module/remote/thriftbackend/thriftgen/pyload/__init__.py
deleted file mode 100644
index ce7f52598..000000000
--- a/module/remote/thriftbackend/thriftgen/pyload/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-__all__ = ['ttypes', 'constants', 'Pyload']
diff --git a/module/remote/thriftbackend/thriftgen/pyload/constants.py b/module/remote/thriftbackend/thriftgen/pyload/constants.py
deleted file mode 100644
index f8960dc63..000000000
--- a/module/remote/thriftbackend/thriftgen/pyload/constants.py
+++ /dev/null
@@ -1,11 +0,0 @@
-#
-# Autogenerated by Thrift Compiler (0.9.0-dev)
-#
-# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
-#
-#  options string: py:slots,dynamic
-#
-
-from thrift.Thrift import TType, TMessageType, TException
-from ttypes import *
-
diff --git a/module/remote/thriftbackend/thriftgen/pyload/ttypes.py b/module/remote/thriftbackend/thriftgen/pyload/ttypes.py
deleted file mode 100644
index 1299b515d..000000000
--- a/module/remote/thriftbackend/thriftgen/pyload/ttypes.py
+++ /dev/null
@@ -1,835 +0,0 @@
-#
-# Autogenerated by Thrift Compiler (0.9.0-dev)
-#
-# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
-#
-#  options string: py:slots,dynamic
-#
-
-from thrift.Thrift import TType, TMessageType, TException
-
-from thrift.protocol.TBase import TBase, TExceptionBase
-
-
-class DownloadStatus(TBase):
-  Finished = 0
-  Offline = 1
-  Online = 2
-  Queued = 3
-  Skipped = 4
-  Waiting = 5
-  TempOffline = 6
-  Starting = 7
-  Failed = 8
-  Aborted = 9
-  Decrypting = 10
-  Custom = 11
-  Downloading = 12
-  Processing = 13
-  Unknown = 14
-
-  _VALUES_TO_NAMES = {
-    0: "Finished",
-    1: "Offline",
-    2: "Online",
-    3: "Queued",
-    4: "Skipped",
-    5: "Waiting",
-    6: "TempOffline",
-    7: "Starting",
-    8: "Failed",
-    9: "Aborted",
-    10: "Decrypting",
-    11: "Custom",
-    12: "Downloading",
-    13: "Processing",
-    14: "Unknown",
-  }
-
-  _NAMES_TO_VALUES = {
-    "Finished": 0,
-    "Offline": 1,
-    "Online": 2,
-    "Queued": 3,
-    "Skipped": 4,
-    "Waiting": 5,
-    "TempOffline": 6,
-    "Starting": 7,
-    "Failed": 8,
-    "Aborted": 9,
-    "Decrypting": 10,
-    "Custom": 11,
-    "Downloading": 12,
-    "Processing": 13,
-    "Unknown": 14,
-  }
-
-class Destination(TBase):
-  Collector = 0
-  Queue = 1
-
-  _VALUES_TO_NAMES = {
-    0: "Collector",
-    1: "Queue",
-  }
-
-  _NAMES_TO_VALUES = {
-    "Collector": 0,
-    "Queue": 1,
-  }
-
-class ElementType(TBase):
-  Package = 0
-  File = 1
-
-  _VALUES_TO_NAMES = {
-    0: "Package",
-    1: "File",
-  }
-
-  _NAMES_TO_VALUES = {
-    "Package": 0,
-    "File": 1,
-  }
-
-class Input(TBase):
-  NONE = 0
-  TEXT = 1
-  TEXTBOX = 2
-  PASSWORD = 3
-  BOOL = 4
-  CLICK = 5
-  CHOICE = 6
-  MULTIPLE = 7
-  LIST = 8
-  TABLE = 9
-
-  _VALUES_TO_NAMES = {
-    0: "NONE",
-    1: "TEXT",
-    2: "TEXTBOX",
-    3: "PASSWORD",
-    4: "BOOL",
-    5: "CLICK",
-    6: "CHOICE",
-    7: "MULTIPLE",
-    8: "LIST",
-    9: "TABLE",
-  }
-
-  _NAMES_TO_VALUES = {
-    "NONE": 0,
-    "TEXT": 1,
-    "TEXTBOX": 2,
-    "PASSWORD": 3,
-    "BOOL": 4,
-    "CLICK": 5,
-    "CHOICE": 6,
-    "MULTIPLE": 7,
-    "LIST": 8,
-    "TABLE": 9,
-  }
-
-class Output(TBase):
-  CAPTCHA = 1
-  QUESTION = 2
-  NOTIFICATION = 4
-
-  _VALUES_TO_NAMES = {
-    1: "CAPTCHA",
-    2: "QUESTION",
-    4: "NOTIFICATION",
-  }
-
-  _NAMES_TO_VALUES = {
-    "CAPTCHA": 1,
-    "QUESTION": 2,
-    "NOTIFICATION": 4,
-  }
-
-
-class DownloadInfo(TBase):
-  """
-  Attributes:
-   - fid
-   - name
-   - speed
-   - eta
-   - format_eta
-   - bleft
-   - size
-   - format_size
-   - percent
-   - status
-   - statusmsg
-   - format_wait
-   - wait_until
-   - packageID
-   - packageName
-   - plugin
-  """
-
-  __slots__ = [ 
-    'fid',
-    'name',
-    'speed',
-    'eta',
-    'format_eta',
-    'bleft',
-    'size',
-    'format_size',
-    'percent',
-    'status',
-    'statusmsg',
-    'format_wait',
-    'wait_until',
-    'packageID',
-    'packageName',
-    'plugin',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.I32, 'fid', None, None, ), # 1
-    (2, TType.STRING, 'name', None, None, ), # 2
-    (3, TType.I64, 'speed', None, None, ), # 3
-    (4, TType.I32, 'eta', None, None, ), # 4
-    (5, TType.STRING, 'format_eta', None, None, ), # 5
-    (6, TType.I64, 'bleft', None, None, ), # 6
-    (7, TType.I64, 'size', None, None, ), # 7
-    (8, TType.STRING, 'format_size', None, None, ), # 8
-    (9, TType.BYTE, 'percent', None, None, ), # 9
-    (10, TType.I32, 'status', None, None, ), # 10
-    (11, TType.STRING, 'statusmsg', None, None, ), # 11
-    (12, TType.STRING, 'format_wait', None, None, ), # 12
-    (13, TType.I64, 'wait_until', None, None, ), # 13
-    (14, TType.I32, 'packageID', None, None, ), # 14
-    (15, TType.STRING, 'packageName', None, None, ), # 15
-    (16, TType.STRING, 'plugin', None, None, ), # 16
-  )
-
-  def __init__(self, fid=None, name=None, speed=None, eta=None, format_eta=None, bleft=None, size=None, format_size=None, percent=None, status=None, statusmsg=None, format_wait=None, wait_until=None, packageID=None, packageName=None, plugin=None,):
-    self.fid = fid
-    self.name = name
-    self.speed = speed
-    self.eta = eta
-    self.format_eta = format_eta
-    self.bleft = bleft
-    self.size = size
-    self.format_size = format_size
-    self.percent = percent
-    self.status = status
-    self.statusmsg = statusmsg
-    self.format_wait = format_wait
-    self.wait_until = wait_until
-    self.packageID = packageID
-    self.packageName = packageName
-    self.plugin = plugin
-
-
-class ServerStatus(TBase):
-  """
-  Attributes:
-   - pause
-   - active
-   - queue
-   - total
-   - speed
-   - download
-   - reconnect
-  """
-
-  __slots__ = [ 
-    'pause',
-    'active',
-    'queue',
-    'total',
-    'speed',
-    'download',
-    'reconnect',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.BOOL, 'pause', None, None, ), # 1
-    (2, TType.I16, 'active', None, None, ), # 2
-    (3, TType.I16, 'queue', None, None, ), # 3
-    (4, TType.I16, 'total', None, None, ), # 4
-    (5, TType.I64, 'speed', None, None, ), # 5
-    (6, TType.BOOL, 'download', None, None, ), # 6
-    (7, TType.BOOL, 'reconnect', None, None, ), # 7
-  )
-
-  def __init__(self, pause=None, active=None, queue=None, total=None, speed=None, download=None, reconnect=None,):
-    self.pause = pause
-    self.active = active
-    self.queue = queue
-    self.total = total
-    self.speed = speed
-    self.download = download
-    self.reconnect = reconnect
-
-
-class ConfigItem(TBase):
-  """
-  Attributes:
-   - name
-   - description
-   - value
-   - type
-  """
-
-  __slots__ = [ 
-    'name',
-    'description',
-    'value',
-    'type',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.STRING, 'name', None, None, ), # 1
-    (2, TType.STRING, 'description', None, None, ), # 2
-    (3, TType.STRING, 'value', None, None, ), # 3
-    (4, TType.STRING, 'type', None, None, ), # 4
-  )
-
-  def __init__(self, name=None, description=None, value=None, type=None,):
-    self.name = name
-    self.description = description
-    self.value = value
-    self.type = type
-
-
-class ConfigSection(TBase):
-  """
-  Attributes:
-   - name
-   - description
-   - items
-   - outline
-  """
-
-  __slots__ = [ 
-    'name',
-    'description',
-    'items',
-    'outline',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.STRING, 'name', None, None, ), # 1
-    (2, TType.STRING, 'description', None, None, ), # 2
-    (3, TType.LIST, 'items', (TType.STRUCT,(ConfigItem, ConfigItem.thrift_spec)), None, ), # 3
-    (4, TType.STRING, 'outline', None, None, ), # 4
-  )
-
-  def __init__(self, name=None, description=None, items=None, outline=None,):
-    self.name = name
-    self.description = description
-    self.items = items
-    self.outline = outline
-
-
-class FileData(TBase):
-  """
-  Attributes:
-   - fid
-   - url
-   - name
-   - plugin
-   - size
-   - format_size
-   - status
-   - statusmsg
-   - packageID
-   - error
-   - order
-  """
-
-  __slots__ = [ 
-    'fid',
-    'url',
-    'name',
-    'plugin',
-    'size',
-    'format_size',
-    'status',
-    'statusmsg',
-    'packageID',
-    'error',
-    'order',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.I32, 'fid', None, None, ), # 1
-    (2, TType.STRING, 'url', None, None, ), # 2
-    (3, TType.STRING, 'name', None, None, ), # 3
-    (4, TType.STRING, 'plugin', None, None, ), # 4
-    (5, TType.I64, 'size', None, None, ), # 5
-    (6, TType.STRING, 'format_size', None, None, ), # 6
-    (7, TType.I32, 'status', None, None, ), # 7
-    (8, TType.STRING, 'statusmsg', None, None, ), # 8
-    (9, TType.I32, 'packageID', None, None, ), # 9
-    (10, TType.STRING, 'error', None, None, ), # 10
-    (11, TType.I16, 'order', None, None, ), # 11
-  )
-
-  def __init__(self, fid=None, url=None, name=None, plugin=None, size=None, format_size=None, status=None, statusmsg=None, packageID=None, error=None, order=None,):
-    self.fid = fid
-    self.url = url
-    self.name = name
-    self.plugin = plugin
-    self.size = size
-    self.format_size = format_size
-    self.status = status
-    self.statusmsg = statusmsg
-    self.packageID = packageID
-    self.error = error
-    self.order = order
-
-
-class PackageData(TBase):
-  """
-  Attributes:
-   - pid
-   - name
-   - folder
-   - site
-   - password
-   - dest
-   - order
-   - linksdone
-   - sizedone
-   - sizetotal
-   - linkstotal
-   - links
-   - fids
-  """
-
-  __slots__ = [ 
-    'pid',
-    'name',
-    'folder',
-    'site',
-    'password',
-    'dest',
-    'order',
-    'linksdone',
-    'sizedone',
-    'sizetotal',
-    'linkstotal',
-    'links',
-    'fids',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.I32, 'pid', None, None, ), # 1
-    (2, TType.STRING, 'name', None, None, ), # 2
-    (3, TType.STRING, 'folder', None, None, ), # 3
-    (4, TType.STRING, 'site', None, None, ), # 4
-    (5, TType.STRING, 'password', None, None, ), # 5
-    (6, TType.I32, 'dest', None, None, ), # 6
-    (7, TType.I16, 'order', None, None, ), # 7
-    (8, TType.I16, 'linksdone', None, None, ), # 8
-    (9, TType.I64, 'sizedone', None, None, ), # 9
-    (10, TType.I64, 'sizetotal', None, None, ), # 10
-    (11, TType.I16, 'linkstotal', None, None, ), # 11
-    (12, TType.LIST, 'links', (TType.STRUCT,(FileData, FileData.thrift_spec)), None, ), # 12
-    (13, TType.LIST, 'fids', (TType.I32,None), None, ), # 13
-  )
-
-  def __init__(self, pid=None, name=None, folder=None, site=None, password=None, dest=None, order=None, linksdone=None, sizedone=None, sizetotal=None, linkstotal=None, links=None, fids=None,):
-    self.pid = pid
-    self.name = name
-    self.folder = folder
-    self.site = site
-    self.password = password
-    self.dest = dest
-    self.order = order
-    self.linksdone = linksdone
-    self.sizedone = sizedone
-    self.sizetotal = sizetotal
-    self.linkstotal = linkstotal
-    self.links = links
-    self.fids = fids
-
-
-class InteractionTask(TBase):
-  """
-  Attributes:
-   - iid
-   - input
-   - structure
-   - preset
-   - output
-   - data
-   - title
-   - description
-   - plugin
-  """
-
-  __slots__ = [ 
-    'iid',
-    'input',
-    'structure',
-    'preset',
-    'output',
-    'data',
-    'title',
-    'description',
-    'plugin',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.I32, 'iid', None, None, ), # 1
-    (2, TType.I32, 'input', None, None, ), # 2
-    (3, TType.LIST, 'structure', (TType.STRING,None), None, ), # 3
-    (4, TType.LIST, 'preset', (TType.STRING,None), None, ), # 4
-    (5, TType.I32, 'output', None, None, ), # 5
-    (6, TType.LIST, 'data', (TType.STRING,None), None, ), # 6
-    (7, TType.STRING, 'title', None, None, ), # 7
-    (8, TType.STRING, 'description', None, None, ), # 8
-    (9, TType.STRING, 'plugin', None, None, ), # 9
-  )
-
-  def __init__(self, iid=None, input=None, structure=None, preset=None, output=None, data=None, title=None, description=None, plugin=None,):
-    self.iid = iid
-    self.input = input
-    self.structure = structure
-    self.preset = preset
-    self.output = output
-    self.data = data
-    self.title = title
-    self.description = description
-    self.plugin = plugin
-
-
-class CaptchaTask(TBase):
-  """
-  Attributes:
-   - tid
-   - data
-   - type
-   - resultType
-  """
-
-  __slots__ = [ 
-    'tid',
-    'data',
-    'type',
-    'resultType',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.I16, 'tid', None, None, ), # 1
-    (2, TType.STRING, 'data', None, None, ), # 2
-    (3, TType.STRING, 'type', None, None, ), # 3
-    (4, TType.STRING, 'resultType', None, None, ), # 4
-  )
-
-  def __init__(self, tid=None, data=None, type=None, resultType=None,):
-    self.tid = tid
-    self.data = data
-    self.type = type
-    self.resultType = resultType
-
-
-class EventInfo(TBase):
-  """
-  Attributes:
-   - eventname
-   - id
-   - type
-   - destination
-  """
-
-  __slots__ = [ 
-    'eventname',
-    'id',
-    'type',
-    'destination',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.STRING, 'eventname', None, None, ), # 1
-    (2, TType.I32, 'id', None, None, ), # 2
-    (3, TType.I32, 'type', None, None, ), # 3
-    (4, TType.I32, 'destination', None, None, ), # 4
-  )
-
-  def __init__(self, eventname=None, id=None, type=None, destination=None,):
-    self.eventname = eventname
-    self.id = id
-    self.type = type
-    self.destination = destination
-
-
-class UserData(TBase):
-  """
-  Attributes:
-   - name
-   - email
-   - role
-   - permission
-   - templateName
-  """
-
-  __slots__ = [ 
-    'name',
-    'email',
-    'role',
-    'permission',
-    'templateName',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.STRING, 'name', None, None, ), # 1
-    (2, TType.STRING, 'email', None, None, ), # 2
-    (3, TType.I32, 'role', None, None, ), # 3
-    (4, TType.I32, 'permission', None, None, ), # 4
-    (5, TType.STRING, 'templateName', None, None, ), # 5
-  )
-
-  def __init__(self, name=None, email=None, role=None, permission=None, templateName=None,):
-    self.name = name
-    self.email = email
-    self.role = role
-    self.permission = permission
-    self.templateName = templateName
-
-
-class AccountInfo(TBase):
-  """
-  Attributes:
-   - validuntil
-   - login
-   - options
-   - valid
-   - trafficleft
-   - maxtraffic
-   - premium
-   - type
-  """
-
-  __slots__ = [ 
-    'validuntil',
-    'login',
-    'options',
-    'valid',
-    'trafficleft',
-    'maxtraffic',
-    'premium',
-    'type',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.I64, 'validuntil', None, None, ), # 1
-    (2, TType.STRING, 'login', None, None, ), # 2
-    (3, TType.MAP, 'options', (TType.STRING,None,TType.LIST,(TType.STRING,None)), None, ), # 3
-    (4, TType.BOOL, 'valid', None, None, ), # 4
-    (5, TType.I64, 'trafficleft', None, None, ), # 5
-    (6, TType.I64, 'maxtraffic', None, None, ), # 6
-    (7, TType.BOOL, 'premium', None, None, ), # 7
-    (8, TType.STRING, 'type', None, None, ), # 8
-  )
-
-  def __init__(self, validuntil=None, login=None, options=None, valid=None, trafficleft=None, maxtraffic=None, premium=None, type=None,):
-    self.validuntil = validuntil
-    self.login = login
-    self.options = options
-    self.valid = valid
-    self.trafficleft = trafficleft
-    self.maxtraffic = maxtraffic
-    self.premium = premium
-    self.type = type
-
-
-class ServiceCall(TBase):
-  """
-  Attributes:
-   - plugin
-   - func
-   - arguments
-   - parseArguments
-  """
-
-  __slots__ = [ 
-    'plugin',
-    'func',
-    'arguments',
-    'parseArguments',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.STRING, 'plugin', None, None, ), # 1
-    (2, TType.STRING, 'func', None, None, ), # 2
-    (3, TType.LIST, 'arguments', (TType.STRING,None), None, ), # 3
-    (4, TType.BOOL, 'parseArguments', None, None, ), # 4
-  )
-
-  def __init__(self, plugin=None, func=None, arguments=None, parseArguments=None,):
-    self.plugin = plugin
-    self.func = func
-    self.arguments = arguments
-    self.parseArguments = parseArguments
-
-
-class OnlineStatus(TBase):
-  """
-  Attributes:
-   - name
-   - plugin
-   - packagename
-   - status
-   - size
-  """
-
-  __slots__ = [ 
-    'name',
-    'plugin',
-    'packagename',
-    'status',
-    'size',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.STRING, 'name', None, None, ), # 1
-    (2, TType.STRING, 'plugin', None, None, ), # 2
-    (3, TType.STRING, 'packagename', None, None, ), # 3
-    (4, TType.I32, 'status', None, None, ), # 4
-    (5, TType.I64, 'size', None, None, ), # 5
-  )
-
-  def __init__(self, name=None, plugin=None, packagename=None, status=None, size=None,):
-    self.name = name
-    self.plugin = plugin
-    self.packagename = packagename
-    self.status = status
-    self.size = size
-
-
-class OnlineCheck(TBase):
-  """
-  Attributes:
-   - rid
-   - data
-  """
-
-  __slots__ = [ 
-    'rid',
-    'data',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.I32, 'rid', None, None, ), # 1
-    (2, TType.MAP, 'data', (TType.STRING,None,TType.STRUCT,(OnlineStatus, OnlineStatus.thrift_spec)), None, ), # 2
-  )
-
-  def __init__(self, rid=None, data=None,):
-    self.rid = rid
-    self.data = data
-
-
-class PackageDoesNotExists(TExceptionBase):
-  """
-  Attributes:
-   - pid
-  """
-
-  __slots__ = [ 
-    'pid',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.I32, 'pid', None, None, ), # 1
-  )
-
-  def __init__(self, pid=None,):
-    self.pid = pid
-
-  def __str__(self):
-    return repr(self)
-
-
-class FileDoesNotExists(TExceptionBase):
-  """
-  Attributes:
-   - fid
-  """
-
-  __slots__ = [ 
-    'fid',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.I32, 'fid', None, None, ), # 1
-  )
-
-  def __init__(self, fid=None,):
-    self.fid = fid
-
-  def __str__(self):
-    return repr(self)
-
-
-class ServiceDoesNotExists(TExceptionBase):
-  """
-  Attributes:
-   - plugin
-   - func
-  """
-
-  __slots__ = [ 
-    'plugin',
-    'func',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.STRING, 'plugin', None, None, ), # 1
-    (2, TType.STRING, 'func', None, None, ), # 2
-  )
-
-  def __init__(self, plugin=None, func=None,):
-    self.plugin = plugin
-    self.func = func
-
-  def __str__(self):
-    return repr(self)
-
-
-class ServiceException(TExceptionBase):
-  """
-  Attributes:
-   - msg
-  """
-
-  __slots__ = [ 
-    'msg',
-   ]
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.STRING, 'msg', None, None, ), # 1
-  )
-
-  def __init__(self, msg=None,):
-    self.msg = msg
-
-  def __str__(self):
-    return repr(self)
-
diff --git a/module/remote/ttypes.py b/module/remote/ttypes.py
new file mode 100644
index 000000000..1f91403d5
--- /dev/null
+++ b/module/remote/ttypes.py
@@ -0,0 +1,534 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Autogenerated by pyload
+# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+
+class BaseObject(object):
+	__slots__ = []
+
+	def __str__(self):
+		return "<%s %s>" % (self.__class__.__name__, ", ".join("%s=%s" % (k,getattr(self,k)) for k in self.__slots__))
+
+class ExceptionObject(Exception):
+	__slots__ = []
+
+class DownloadState:
+	All = 0
+	Finished = 1
+	Unfinished = 2
+	Failed = 3
+	Unmanaged = 4
+
+class DownloadStatus:
+	NA = 0
+	Offline = 1
+	Online = 2
+	Queued = 3
+	Paused = 4
+	Finished = 5
+	Skipped = 6
+	Failed = 7
+	Starting = 8
+	Waiting = 9
+	Downloading = 10
+	TempOffline = 11
+	Aborted = 12
+	Decrypting = 13
+	Processing = 14
+	Custom = 15
+	Unknown = 16
+
+class FileStatus:
+	Ok = 0
+	Missing = 1
+	Remote = 2
+
+class Input:
+	NA = 0
+	Text = 1
+	Int = 2
+	File = 3
+	Folder = 4
+	Textbox = 5
+	Password = 6
+	Bool = 7
+	Click = 8
+	Select = 9
+	Multiple = 10
+	List = 11
+	Table = 12
+
+class MediaType:
+	All = 0
+	Other = 1
+	Audio = 2
+	Image = 4
+	Video = 8
+	Document = 16
+	Archive = 32
+
+class Output:
+	All = 0
+	Notification = 1
+	Captcha = 2
+	Query = 4
+
+class PackageStatus:
+	Ok = 0
+	Paused = 1
+	Folder = 2
+	Remote = 3
+
+class Permission:
+	All = 0
+	Add = 1
+	Delete = 2
+	Modify = 4
+	Download = 8
+	Accounts = 16
+	Interaction = 32
+	Plugins = 64
+
+class Role:
+	Admin = 0
+	User = 1
+
+class AccountInfo(BaseObject):
+	__slots__ = ['plugin', 'loginname', 'owner', 'valid', 'validuntil', 'trafficleft', 'maxtraffic', 'premium', 'activated', 'shared', 'options']
+
+	def __init__(self, plugin=None, loginname=None, owner=None, valid=None, validuntil=None, trafficleft=None, maxtraffic=None, premium=None, activated=None, shared=None, options=None):
+		self.plugin = plugin
+		self.loginname = loginname
+		self.owner = owner
+		self.valid = valid
+		self.validuntil = validuntil
+		self.trafficleft = trafficleft
+		self.maxtraffic = maxtraffic
+		self.premium = premium
+		self.activated = activated
+		self.shared = shared
+		self.options = options
+
+class AddonInfo(BaseObject):
+	__slots__ = ['func_name', 'description', 'value']
+
+	def __init__(self, func_name=None, description=None, value=None):
+		self.func_name = func_name
+		self.description = description
+		self.value = value
+
+class AddonService(BaseObject):
+	__slots__ = ['func_name', 'description', 'arguments', 'media']
+
+	def __init__(self, func_name=None, description=None, arguments=None, media=None):
+		self.func_name = func_name
+		self.description = description
+		self.arguments = arguments
+		self.media = media
+
+class ConfigHolder(BaseObject):
+	__slots__ = ['name', 'label', 'description', 'long_description', 'items', 'info', 'handler']
+
+	def __init__(self, name=None, label=None, description=None, long_description=None, items=None, info=None, handler=None):
+		self.name = name
+		self.label = label
+		self.description = description
+		self.long_description = long_description
+		self.items = items
+		self.info = info
+		self.handler = handler
+
+class ConfigInfo(BaseObject):
+	__slots__ = ['name', 'label', 'description', 'category', 'user_context', 'activated']
+
+	def __init__(self, name=None, label=None, description=None, category=None, user_context=None, activated=None):
+		self.name = name
+		self.label = label
+		self.description = description
+		self.category = category
+		self.user_context = user_context
+		self.activated = activated
+
+class ConfigItem(BaseObject):
+	__slots__ = ['name', 'label', 'description', 'type', 'default_value', 'value']
+
+	def __init__(self, name=None, label=None, description=None, type=None, default_value=None, value=None):
+		self.name = name
+		self.label = label
+		self.description = description
+		self.type = type
+		self.default_value = default_value
+		self.value = value
+
+class DownloadInfo(BaseObject):
+	__slots__ = ['url', 'plugin', 'hash', 'status', 'statusmsg', 'error']
+
+	def __init__(self, url=None, plugin=None, hash=None, status=None, statusmsg=None, error=None):
+		self.url = url
+		self.plugin = plugin
+		self.hash = hash
+		self.status = status
+		self.statusmsg = statusmsg
+		self.error = error
+
+class DownloadProgress(BaseObject):
+	__slots__ = ['fid', 'pid', 'speed', 'status']
+
+	def __init__(self, fid=None, pid=None, speed=None, status=None):
+		self.fid = fid
+		self.pid = pid
+		self.speed = speed
+		self.status = status
+
+class EventInfo(BaseObject):
+	__slots__ = ['eventname', 'event_args']
+
+	def __init__(self, eventname=None, event_args=None):
+		self.eventname = eventname
+		self.event_args = event_args
+
+class FileDoesNotExists(ExceptionObject):
+	__slots__ = ['fid']
+
+	def __init__(self, fid=None):
+		self.fid = fid
+
+class FileInfo(BaseObject):
+	__slots__ = ['fid', 'name', 'package', 'owner', 'size', 'status', 'media', 'added', 'fileorder', 'download']
+
+	def __init__(self, fid=None, name=None, package=None, owner=None, size=None, status=None, media=None, added=None, fileorder=None, download=None):
+		self.fid = fid
+		self.name = name
+		self.package = package
+		self.owner = owner
+		self.size = size
+		self.status = status
+		self.media = media
+		self.added = added
+		self.fileorder = fileorder
+		self.download = download
+
+class Forbidden(ExceptionObject):
+	pass
+
+class InteractionTask(BaseObject):
+	__slots__ = ['iid', 'input', 'data', 'output', 'default_value', 'title', 'description', 'plugin']
+
+	def __init__(self, iid=None, input=None, data=None, output=None, default_value=None, title=None, description=None, plugin=None):
+		self.iid = iid
+		self.input = input
+		self.data = data
+		self.output = output
+		self.default_value = default_value
+		self.title = title
+		self.description = description
+		self.plugin = plugin
+
+class InvalidConfigSection(ExceptionObject):
+	__slots__ = ['section']
+
+	def __init__(self, section=None):
+		self.section = section
+
+class LinkStatus(BaseObject):
+	__slots__ = ['url', 'name', 'plugin', 'size', 'status', 'packagename']
+
+	def __init__(self, url=None, name=None, plugin=None, size=None, status=None, packagename=None):
+		self.url = url
+		self.name = name
+		self.plugin = plugin
+		self.size = size
+		self.status = status
+		self.packagename = packagename
+
+class OnlineCheck(BaseObject):
+	__slots__ = ['rid', 'data']
+
+	def __init__(self, rid=None, data=None):
+		self.rid = rid
+		self.data = data
+
+class PackageDoesNotExists(ExceptionObject):
+	__slots__ = ['pid']
+
+	def __init__(self, pid=None):
+		self.pid = pid
+
+class PackageInfo(BaseObject):
+	__slots__ = ['pid', 'name', 'folder', 'root', 'owner', 'site', 'comment', 'password', 'added', 'tags', 'status', 'shared', 'packageorder', 'stats', 'fids', 'pids']
+
+	def __init__(self, pid=None, name=None, folder=None, root=None, owner=None, site=None, comment=None, password=None, added=None, tags=None, status=None, shared=None, packageorder=None, stats=None, fids=None, pids=None):
+		self.pid = pid
+		self.name = name
+		self.folder = folder
+		self.root = root
+		self.owner = owner
+		self.site = site
+		self.comment = comment
+		self.password = password
+		self.added = added
+		self.tags = tags
+		self.status = status
+		self.shared = shared
+		self.packageorder = packageorder
+		self.stats = stats
+		self.fids = fids
+		self.pids = pids
+
+class PackageStats(BaseObject):
+	__slots__ = ['linkstotal', 'linksdone', 'sizetotal', 'sizedone']
+
+	def __init__(self, linkstotal=None, linksdone=None, sizetotal=None, sizedone=None):
+		self.linkstotal = linkstotal
+		self.linksdone = linksdone
+		self.sizetotal = sizetotal
+		self.sizedone = sizedone
+
+class ProgressInfo(BaseObject):
+	__slots__ = ['plugin', 'name', 'statusmsg', 'eta', 'done', 'total', 'download']
+
+	def __init__(self, plugin=None, name=None, statusmsg=None, eta=None, done=None, total=None, download=None):
+		self.plugin = plugin
+		self.name = name
+		self.statusmsg = statusmsg
+		self.eta = eta
+		self.done = done
+		self.total = total
+		self.download = download
+
+class ServerStatus(BaseObject):
+	__slots__ = ['queuedDownloads', 'totalDownloads', 'speed', 'pause', 'download', 'reconnect']
+
+	def __init__(self, queuedDownloads=None, totalDownloads=None, speed=None, pause=None, download=None, reconnect=None):
+		self.queuedDownloads = queuedDownloads
+		self.totalDownloads = totalDownloads
+		self.speed = speed
+		self.pause = pause
+		self.download = download
+		self.reconnect = reconnect
+
+class ServiceDoesNotExists(ExceptionObject):
+	__slots__ = ['plugin', 'func']
+
+	def __init__(self, plugin=None, func=None):
+		self.plugin = plugin
+		self.func = func
+
+class ServiceException(ExceptionObject):
+	__slots__ = ['msg']
+
+	def __init__(self, msg=None):
+		self.msg = msg
+
+class TreeCollection(BaseObject):
+	__slots__ = ['root', 'files', 'packages']
+
+	def __init__(self, root=None, files=None, packages=None):
+		self.root = root
+		self.files = files
+		self.packages = packages
+
+class Unauthorized(ExceptionObject):
+	pass
+
+class UserData(BaseObject):
+	__slots__ = ['uid', 'name', 'email', 'role', 'permission', 'folder', 'traffic', 'dllimit', 'dlquota', 'hddquota', 'user', 'templateName']
+
+	def __init__(self, uid=None, name=None, email=None, role=None, permission=None, folder=None, traffic=None, dllimit=None, dlquota=None, hddquota=None, user=None, templateName=None):
+		self.uid = uid
+		self.name = name
+		self.email = email
+		self.role = role
+		self.permission = permission
+		self.folder = folder
+		self.traffic = traffic
+		self.dllimit = dllimit
+		self.dlquota = dlquota
+		self.hddquota = hddquota
+		self.user = user
+		self.templateName = templateName
+
+class UserDoesNotExists(ExceptionObject):
+	__slots__ = ['user']
+
+	def __init__(self, user=None):
+		self.user = user
+
+class Iface(object):
+	def addFromCollector(self, name, paused):
+		pass
+	def addLinks(self, pid, links):
+		pass
+	def addLocalFile(self, pid, name, path):
+		pass
+	def addPackage(self, name, links, password):
+		pass
+	def addPackageChild(self, name, links, password, root, paused):
+		pass
+	def addPackageP(self, name, links, password, paused):
+		pass
+	def addToCollector(self, links):
+		pass
+	def addUser(self, username, password):
+		pass
+	def callAddon(self, plugin, func, arguments):
+		pass
+	def callAddonHandler(self, plugin, func, pid_or_fid):
+		pass
+	def checkOnlineStatus(self, urls):
+		pass
+	def checkOnlineStatusContainer(self, urls, filename, data):
+		pass
+	def checkURLs(self, urls):
+		pass
+	def configurePlugin(self, plugin):
+		pass
+	def createPackage(self, name, folder, root, password, site, comment, paused):
+		pass
+	def deleteCollLink(self, url):
+		pass
+	def deleteCollPack(self, name):
+		pass
+	def deleteConfig(self, plugin):
+		pass
+	def deleteFiles(self, fids):
+		pass
+	def deletePackages(self, pids):
+		pass
+	def findFiles(self, pattern):
+		pass
+	def findPackages(self, tags):
+		pass
+	def freeSpace(self):
+		pass
+	def generateAndAddPackages(self, links, paused):
+		pass
+	def generateDownloadLink(self, fid, timeout):
+		pass
+	def generatePackages(self, links):
+		pass
+	def getAccountTypes(self):
+		pass
+	def getAccounts(self, refresh):
+		pass
+	def getAddonHandler(self):
+		pass
+	def getAllFiles(self):
+		pass
+	def getAllUserData(self):
+		pass
+	def getAutocompletion(self, pattern):
+		pass
+	def getAvailablePlugins(self):
+		pass
+	def getCollector(self):
+		pass
+	def getConfig(self):
+		pass
+	def getConfigValue(self, section, option):
+		pass
+	def getCoreConfig(self):
+		pass
+	def getEvents(self, uuid):
+		pass
+	def getFileInfo(self, fid):
+		pass
+	def getFileTree(self, pid, full):
+		pass
+	def getFilteredFileTree(self, pid, full, state):
+		pass
+	def getFilteredFiles(self, state):
+		pass
+	def getInteractionTask(self, mode):
+		pass
+	def getLog(self, offset):
+		pass
+	def getNotifications(self):
+		pass
+	def getPackageContent(self, pid):
+		pass
+	def getPackageInfo(self, pid):
+		pass
+	def getPluginConfig(self):
+		pass
+	def getProgressInfo(self):
+		pass
+	def getServerStatus(self):
+		pass
+	def getServerVersion(self):
+		pass
+	def getUserData(self):
+		pass
+	def getWSAddress(self):
+		pass
+	def hasAddonHandler(self, plugin, func):
+		pass
+	def isInteractionWaiting(self, mode):
+		pass
+	def login(self, username, password):
+		pass
+	def moveFiles(self, fids, pid):
+		pass
+	def movePackage(self, pid, root):
+		pass
+	def orderFiles(self, fids, pid, position):
+		pass
+	def orderPackage(self, pids, position):
+		pass
+	def parseURLs(self, html, url):
+		pass
+	def pauseServer(self):
+		pass
+	def pollResults(self, rid):
+		pass
+	def quit(self):
+		pass
+	def recheckPackage(self, pid):
+		pass
+	def removeAccount(self, plugin, account):
+		pass
+	def removeUser(self, uid):
+		pass
+	def renameCollPack(self, name, new_name):
+		pass
+	def restart(self):
+		pass
+	def restartFailed(self):
+		pass
+	def restartFile(self, fid):
+		pass
+	def restartPackage(self, pid):
+		pass
+	def saveConfig(self, config):
+		pass
+	def setConfigHandler(self, plugin, iid, value):
+		pass
+	def setConfigValue(self, section, option, value):
+		pass
+	def setInteractionResult(self, iid, result):
+		pass
+	def setPackageFolder(self, pid, path):
+		pass
+	def setPassword(self, username, old_password, new_password):
+		pass
+	def stopAllDownloads(self):
+		pass
+	def stopDownloads(self, fids):
+		pass
+	def togglePause(self):
+		pass
+	def toggleReconnect(self):
+		pass
+	def unpauseServer(self):
+		pass
+	def updateAccount(self, plugin, account, password):
+		pass
+	def updateAccountInfo(self, account):
+		pass
+	def updatePackage(self, pack):
+		pass
+	def updateUserData(self, data):
+		pass
+	def uploadContainer(self, filename, data):
+		pass
+
diff --git a/module/remote/wsbackend/AbstractHandler.py b/module/remote/wsbackend/AbstractHandler.py
new file mode 100644
index 000000000..07cc79c74
--- /dev/null
+++ b/module/remote/wsbackend/AbstractHandler.py
@@ -0,0 +1,133 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+###############################################################################
+#   Copyright(c) 2008-2012 pyLoad Team
+#   http://www.pyload.org
+#
+#   This file is part of pyLoad.
+#   pyLoad is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU Affero General Public License as
+#   published by the Free Software Foundation, either version 3 of the
+#   License, or (at your option) any later version.
+#
+#   Subjected to the terms and conditions in LICENSE
+#
+#   @author: RaNaN
+###############################################################################
+
+from mod_pywebsocket.msgutil import send_message
+from mod_pywebsocket.util import get_class_logger
+from module.remote.json_converter import loads, dumps
+
+
+class AbstractHandler:
+    """
+        Abstract Handler providing common methods shared across WebSocket handlers
+    """
+    PATH = "/"
+
+    OK = 200
+    BAD_REQUEST = 400
+    UNAUTHORIZED = 401
+    FORBIDDEN = 403
+    NOT_FOUND = 404
+    ERROR = 500
+
+    def __init__(self, api):
+        self.log = get_class_logger()
+        self.api = api
+        self.core = api.core
+
+    def do_extra_handshake(self, req):
+        self.log.debug("WS Connected: %s" % req)
+        req.api = None #when api is set client is logged in
+
+        # allow login via session when webinterface is active
+        if self.core.config['webinterface']['activated']:
+            cookie = req.headers_in.getheader('Cookie')
+            s = self.load_session(cookie)
+            if s:
+                uid = s.get('uid', None)
+                req.api = self.api.withUserContext(uid)
+                self.log.debug("WS authenticated user with cookie: %d" % uid)
+
+        self.on_open(req)
+
+    def on_open(self, req):
+        pass
+
+    def load_session(self, cookies):
+        from Cookie import SimpleCookie
+        from beaker.session import Session
+        from module.web.webinterface import session
+
+        cookies = SimpleCookie(cookies)
+        sid = cookies.get(session.options['key'])
+        if not sid:
+            return None
+
+        s = Session({}, use_cookies=False, id=sid.value, **session.options)
+        if s.is_new:
+            return None
+
+        return s
+
+    def passive_closing_handshake(self, req):
+        self.log.debug("WS Closed: %s" % req)
+        self.on_close(req)
+
+    def on_close(self, req):
+        pass
+
+    def transfer_data(self, req):
+        raise NotImplemented
+
+    def handle_call(self, msg, req):
+        """ Parses the msg for an argument call. If func is null an response was already sent.
+
+        :return: func, args, kwargs
+        """
+        try:
+            o = loads(msg)
+        except ValueError, e: #invalid json object
+            self.log.debug("Invalid Request: %s" % e)
+            self.send_result(req, self.ERROR, "No JSON request")
+            return None, None, None
+
+        if not isinstance(o, basestring) and type(o) != list and len(o) not in range(1, 4):
+            self.log.debug("Invalid Api call: %s" % o)
+            self.send_result(req, self.ERROR, "Invalid Api call")
+            return None, None, None
+
+        # called only with name, no args
+        if isinstance(o, basestring):
+            return o, [], {}
+        elif len(o) == 1: # arguments omitted
+            return o[0], [], {}
+        elif len(o) == 2:
+            func, args = o
+            if type(args) == list:
+                return func, args, {}
+            else:
+                return func, [], args
+        else:
+            return tuple(o)
+
+    def do_login(self, req, args, kwargs):
+        user = self.api.checkAuth(*args, **kwargs)
+        if user:
+            req.api = self.api.withUserContext(user.uid)
+            return self.send_result(req, self.OK, True)
+        else:
+            return self.send_result(req, self.FORBIDDEN, "Forbidden")
+
+    def do_logout(self, req):
+        req.api = None
+        return self.send_result(req, self.OK, True)
+
+    def send_result(self, req, code, result):
+        return send_message(req, dumps([code, result]))
+
+    def send(self, req, obj):
+        return send_message(req, dumps(obj))
\ No newline at end of file
diff --git a/module/remote/wsbackend/ApiHandler.py b/module/remote/wsbackend/ApiHandler.py
new file mode 100644
index 000000000..e985e10be
--- /dev/null
+++ b/module/remote/wsbackend/ApiHandler.py
@@ -0,0 +1,81 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+###############################################################################
+#   Copyright(c) 2008-2012 pyLoad Team
+#   http://www.pyload.org
+#
+#   This file is part of pyLoad.
+#   pyLoad is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU Affero General Public License as
+#   published by the Free Software Foundation, either version 3 of the
+#   License, or (at your option) any later version.
+#
+#   Subjected to the terms and conditions in LICENSE
+#
+#   @author: RaNaN
+###############################################################################
+
+from mod_pywebsocket.msgutil import receive_message
+
+from module.Api import ExceptionObject
+
+from AbstractHandler import AbstractHandler
+
+class ApiHandler(AbstractHandler):
+    """Provides access to the API.
+
+    Send your request as json encoded string in the following manner:
+    ["function", [*args]] or ["function", {**kwargs}]
+
+    the result will be:
+
+    [code, result]
+
+    Don't forget to login first.
+    Non json request will be ignored.
+    """
+
+    PATH = "/api"
+
+    def transfer_data(self, req):
+        while True:
+            try:
+                line = receive_message(req)
+            except TypeError, e: # connection closed
+                self.log.debug("WS Error: %s" % e)
+                return self.passive_closing_handshake(req)
+
+            self.handle_message(line, req)
+
+    def handle_message(self, msg, req):
+
+        func, args, kwargs = self.handle_call(msg, req)
+        if not func:
+            return # handle_call already sent the result
+
+        if func == 'login':
+            return self.do_login(req, args, kwargs)
+        elif func == 'logout':
+            return self.do_logout(req)
+        else:
+            if not req.api:
+                return self.send_result(req, self.FORBIDDEN, "Forbidden")
+
+            if not self.api.isAuthorized(func, req.api.user):
+                return self.send_result(req, self.UNAUTHORIZED, "Unauthorized")
+
+            try:
+                result = getattr(req.api, func)(*args, **kwargs)
+            except ExceptionObject, e:
+                return self.send_result(req, self.BAD_REQUEST, e)
+            except AttributeError:
+                return self.send_result(req, self.NOT_FOUND, "Not Found")
+            except Exception, e:
+                self.core.print_exc()
+                return self.send_result(req, self.ERROR, str(e))
+
+            # None is invalid json type
+            if result is None: result = True
+
+            return self.send_result(req, self.OK, result)
\ No newline at end of file
diff --git a/module/remote/wsbackend/AsyncHandler.py b/module/remote/wsbackend/AsyncHandler.py
new file mode 100644
index 000000000..b40f0ea4e
--- /dev/null
+++ b/module/remote/wsbackend/AsyncHandler.py
@@ -0,0 +1,163 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+###############################################################################
+#   Copyright(c) 2008-2012 pyLoad Team
+#   http://www.pyload.org
+#
+#   This file is part of pyLoad.
+#   pyLoad is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU Affero General Public License as
+#   published by the Free Software Foundation, either version 3 of the
+#   License, or (at your option) any later version.
+#
+#   Subjected to the terms and conditions in LICENSE
+#
+#   @author: RaNaN
+###############################################################################
+
+import re
+from Queue import Queue, Empty
+from threading import Lock
+from time import time
+
+from mod_pywebsocket.msgutil import receive_message
+
+from module.Api import EventInfo, Interaction
+from module.utils import lock
+from AbstractHandler import AbstractHandler
+
+class Mode:
+    STANDBY = 1
+    RUNNING = 2
+
+class AsyncHandler(AbstractHandler):
+    """
+        Handler that provides asynchronous information about server status, running downloads, occurred events.
+
+        Progress information are continuous and will be pushed in a fixed interval when available.
+        After connect you have to login and can set the interval by sending the json command ["setInterval", xy].
+        To start receiving updates call "start", afterwards no more incoming messages will be accepted!
+    """
+
+    PATH = "/async"
+    COMMAND = "start"
+
+    PROGRESS_INTERVAL = 2
+    EVENT_PATTERN = re.compile(r"^(package|file|interaction)", re.I)
+    INTERACTION = Interaction.All
+
+    def __init__(self, api):
+        AbstractHandler.__init__(self, api)
+        self.clients = []
+        self.lock = Lock()
+
+        self.core.evm.addEvent("event", self.add_event)
+
+    @lock
+    def on_open(self, req):
+        req.queue = Queue()
+        req.interval = self.PROGRESS_INTERVAL
+        req.events = self.EVENT_PATTERN
+        req.interaction = self.INTERACTION
+        req.mode = Mode.STANDBY
+        req.t = time() # time when update should be pushed
+        self.clients.append(req)
+
+    @lock
+    def on_close(self, req):
+        try:
+            del req.queue
+            self.clients.remove(req)
+        except ValueError: # ignore when not in list
+            pass
+
+    @lock
+    def add_event(self, event, *args):
+        # Convert arguments to json suited instance
+        event = EventInfo(event, [x.toInfoData() if hasattr(x, 'toInfoData') else x for x in args])
+
+        for req in self.clients:
+            # filter events that these user is no owner of
+            # TODO: events are security critical, this should be revised later
+            if not req.api.user.isAdmin():
+                skip = False
+                for arg in args:
+                    if hasattr(arg, 'owner') and arg.owner != req.api.primaryUID:
+                        skip = True
+                        break
+
+                # user should not get this event
+                if skip: break
+
+            if req.events.search(event.eventname):
+                self.log.debug("Pushing event %s" % event)
+                req.queue.put(event)
+
+    def transfer_data(self, req):
+        while True:
+
+            if req.mode == Mode.STANDBY:
+                try:
+                    line = receive_message(req)
+                except TypeError, e: # connection closed
+                    self.log.debug("WS Error: %s" % e)
+                    return self.passive_closing_handshake(req)
+
+                self.mode_standby(line, req)
+            else:
+                if self.mode_running(req):
+                    return self.passive_closing_handshake(req)
+
+    def mode_standby(self, msg, req):
+        """ accepts calls  before pushing updates """
+        func, args, kwargs = self.handle_call(msg, req)
+        if not func:
+            return # Result was already sent
+
+        if func == 'login':
+            return self.do_login(req, args, kwargs)
+
+        elif func == 'logout':
+            return self.do_logout(req)
+
+        else:
+            if not req.api:
+                return self.send_result(req, self.FORBIDDEN, "Forbidden")
+
+            if func == "setInterval":
+                req.interval = args[0]
+            elif func == "setEvents":
+                req.events = re.compile(args[0], re.I)
+            elif func == "setInteraction":
+                req.interaction = args[0]
+            elif func == self.COMMAND:
+                req.mode = Mode.RUNNING
+
+
+    def mode_running(self, req):
+        """  Listen for events, closes socket when returning True """
+        try:
+            # block length of update interval if necessary
+            ev = req.queue.get(True, req.interval)
+            try:
+                self.send(req, ev)
+            except TypeError:
+                self.log.debug("Event %s not converted" % ev)
+                ev.event_args = []
+                # Resend the event without arguments
+                self.send(req, ev)
+
+        except Empty:
+            pass
+
+        if req.t <= time():
+            # TODO: server status is not enough
+            # modify core api to include progress? think of other needed information to show
+            # eta is quite wrong currently
+            # notifications
+            self.send(req, self.api.getServerStatus())
+            self.send(req, self.api.getProgressInfo())
+
+            # update time for next update
+            req.t = time() + req.interval
\ No newline at end of file
diff --git a/module/remote/wsbackend/Dispatcher.py b/module/remote/wsbackend/Dispatcher.py
new file mode 100644
index 000000000..44cc7555e
--- /dev/null
+++ b/module/remote/wsbackend/Dispatcher.py
@@ -0,0 +1,31 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+###############################################################################
+#   Copyright(c) 2008-2012 pyLoad Team
+#   http://www.pyload.org
+#
+#   This file is part of pyLoad.
+#   pyLoad is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU Affero General Public License as
+#   published by the Free Software Foundation, either version 3 of the
+#   License, or (at your option) any later version.
+#
+#   Subjected to the terms and conditions in LICENSE
+#
+#   @author: RaNaN
+###############################################################################
+
+from mod_pywebsocket import util
+from mod_pywebsocket.dispatch import Dispatcher as BaseDispatcher
+
+class Dispatcher(BaseDispatcher):
+
+    def __init__(self):
+        self._logger = util.get_class_logger(self)
+
+        self._handler_suite_map = {}
+        self._source_warnings = []
+
+    def addHandler(self, path, handler):
+        self._handler_suite_map[path] = handler
\ No newline at end of file
diff --git a/module/remote/wsbackend/Server.py b/module/remote/wsbackend/Server.py
new file mode 100644
index 000000000..9b52f5464
--- /dev/null
+++ b/module/remote/wsbackend/Server.py
@@ -0,0 +1,724 @@
+#!/usr/bin/env python
+#
+# Copyright 2012, Google Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+# A copy of standalone.py with uneeded stuff removed
+# some logging methods removed
+# Added api attribute to request
+
+import BaseHTTPServer
+import CGIHTTPServer
+import SocketServer
+import httplib
+import logging
+import os
+import re
+import select
+import socket
+import sys
+import threading
+
+_HAS_SSL = False
+_HAS_OPEN_SSL = False
+
+from mod_pywebsocket import common
+from mod_pywebsocket import dispatch
+from mod_pywebsocket import handshake
+from mod_pywebsocket import http_header_util
+from mod_pywebsocket import memorizingfile
+from mod_pywebsocket import util
+
+
+_DEFAULT_LOG_MAX_BYTES = 1024 * 256
+_DEFAULT_LOG_BACKUP_COUNT = 5
+
+_DEFAULT_REQUEST_QUEUE_SIZE = 128
+
+# 1024 is practically large enough to contain WebSocket handshake lines.
+_MAX_MEMORIZED_LINES = 1024
+
+def import_ssl():
+    global _HAS_SSL, _HAS_OPEN_SSL
+    try:
+        import ssl
+        _HAS_SSL = True
+    except ImportError:
+        try:
+            import OpenSSL.SSL
+            _HAS_OPEN_SSL = True
+        except ImportError:
+            pass
+
+
+class _StandaloneConnection(object):
+    """Mimic mod_python mp_conn."""
+
+    def __init__(self, request_handler):
+        """Construct an instance.
+
+        Args:
+            request_handler: A WebSocketRequestHandler instance.
+        """
+
+        self._request_handler = request_handler
+
+    def get_local_addr(self):
+        """Getter to mimic mp_conn.local_addr."""
+
+        return (self._request_handler.server.server_name,
+                self._request_handler.server.server_port)
+    local_addr = property(get_local_addr)
+
+    def get_remote_addr(self):
+        """Getter to mimic mp_conn.remote_addr.
+
+        Setting the property in __init__ won't work because the request
+        handler is not initialized yet there."""
+
+        return self._request_handler.client_address
+    remote_addr = property(get_remote_addr)
+
+    def write(self, data):
+        """Mimic mp_conn.write()."""
+
+        return self._request_handler.wfile.write(data)
+
+    def read(self, length):
+        """Mimic mp_conn.read()."""
+
+        return self._request_handler.rfile.read(length)
+
+    def get_memorized_lines(self):
+        """Get memorized lines."""
+
+        return self._request_handler.rfile.get_memorized_lines()
+
+
+class _StandaloneRequest(object):
+    """Mimic mod_python request."""
+
+    def __init__(self, request_handler, use_tls):
+        """Construct an instance.
+
+        Args:
+            request_handler: A WebSocketRequestHandler instance.
+        """
+
+        self._logger = util.get_class_logger(self)
+
+        self._request_handler = request_handler
+        self.connection = _StandaloneConnection(request_handler)
+        self._use_tls = use_tls
+        self.headers_in = request_handler.headers
+
+    def get_uri(self):
+        """Getter to mimic request.uri."""
+
+        return self._request_handler.path
+    uri = property(get_uri)
+
+    def get_method(self):
+        """Getter to mimic request.method."""
+
+        return self._request_handler.command
+    method = property(get_method)
+
+    def get_protocol(self):
+        """Getter to mimic request.protocol."""
+
+        return self._request_handler.request_version
+    protocol = property(get_protocol)
+
+    def is_https(self):
+        """Mimic request.is_https()."""
+
+        return self._use_tls
+
+    def _drain_received_data(self):
+        """Don't use this method from WebSocket handler. Drains unread data
+        in the receive buffer.
+        """
+
+        raw_socket = self._request_handler.connection
+        drained_data = util.drain_received_data(raw_socket)
+
+        if drained_data:
+            self._logger.debug(
+                'Drained data following close frame: %r', drained_data)
+
+
+class _StandaloneSSLConnection(object):
+    """A wrapper class for OpenSSL.SSL.Connection to provide makefile method
+    which is not supported by the class.
+    """
+
+    def __init__(self, connection):
+        self._connection = connection
+
+    def __getattribute__(self, name):
+        if name in ('_connection', 'makefile'):
+            return object.__getattribute__(self, name)
+        return self._connection.__getattribute__(name)
+
+    def __setattr__(self, name, value):
+        if name in ('_connection', 'makefile'):
+            return object.__setattr__(self, name, value)
+        return self._connection.__setattr__(name, value)
+
+    def makefile(self, mode='r', bufsize=-1):
+        return socket._fileobject(self._connection, mode, bufsize)
+
+
+def _alias_handlers(dispatcher, websock_handlers_map_file):
+    """Set aliases specified in websock_handler_map_file in dispatcher.
+
+    Args:
+        dispatcher: dispatch.Dispatcher instance
+        websock_handler_map_file: alias map file
+    """
+
+    fp = open(websock_handlers_map_file)
+    try:
+        for line in fp:
+            if line[0] == '#' or line.isspace():
+                continue
+            m = re.match('(\S+)\s+(\S+)', line)
+            if not m:
+                logging.warning('Wrong format in map file:' + line)
+                continue
+            try:
+                dispatcher.add_resource_path_alias(
+                    m.group(1), m.group(2))
+            except dispatch.DispatchException, e:
+                logging.error(str(e))
+    finally:
+        fp.close()
+
+
+class WebSocketServer(SocketServer.ThreadingMixIn, BaseHTTPServer.HTTPServer):
+    """HTTPServer specialized for WebSocket."""
+
+    # Overrides SocketServer.ThreadingMixIn.daemon_threads
+    daemon_threads = True
+    # Overrides BaseHTTPServer.HTTPServer.allow_reuse_address
+    allow_reuse_address = True
+
+    def __init__(self, options):
+        """Override SocketServer.TCPServer.__init__ to set SSL enabled
+        socket object to self.socket before server_bind and server_activate,
+        if necessary.
+        """
+        # Removed dispatcher init here
+        self._logger = logging.getLogger("log")
+
+        self.request_queue_size = options.request_queue_size
+        self.__ws_is_shut_down = threading.Event()
+        self.__ws_serving = False
+
+        SocketServer.BaseServer.__init__(
+            self, (options.server_host, options.port), WebSocketRequestHandler)
+
+        # Expose the options object to allow handler objects access it. We name
+        # it with websocket_ prefix to avoid conflict.
+        self.websocket_server_options = options
+
+        self._create_sockets()
+        self.server_bind()
+        self.server_activate()
+
+    def _create_sockets(self):
+        self.server_name, self.server_port = self.server_address
+        self._sockets = []
+        if not self.server_name:
+            # On platforms that doesn't support IPv6, the first bind fails.
+            # On platforms that supports IPv6
+            # - If it binds both IPv4 and IPv6 on call with AF_INET6, the
+            #   first bind succeeds and the second fails (we'll see 'Address
+            #   already in use' error).
+            # - If it binds only IPv6 on call with AF_INET6, both call are
+            #   expected to succeed to listen both protocol.
+            addrinfo_array = [
+                (socket.AF_INET6, socket.SOCK_STREAM, '', '', ''),
+                (socket.AF_INET, socket.SOCK_STREAM, '', '', '')]
+        else:
+            addrinfo_array = socket.getaddrinfo(self.server_name,
+                                                self.server_port,
+                                                socket.AF_UNSPEC,
+                                                socket.SOCK_STREAM,
+                                                socket.IPPROTO_TCP)
+        for addrinfo in addrinfo_array:
+            family, socktype, proto, canonname, sockaddr = addrinfo
+            try:
+                socket_ = socket.socket(family, socktype)
+            except Exception, e:
+                self._logger.info('Skip by failure: %r', e)
+                continue
+            if self.websocket_server_options.use_tls:
+                if _HAS_SSL:
+                    if self.websocket_server_options.tls_client_auth:
+                        client_cert_ = ssl.CERT_REQUIRED
+                    else:
+                        client_cert_ = ssl.CERT_NONE
+                    socket_ = ssl.wrap_socket(socket_,
+                                              keyfile=self.websocket_server_options.private_key,
+                                              certfile=self.websocket_server_options.certificate,
+                                              ssl_version=ssl.PROTOCOL_SSLv23,
+                                              ca_certs=self.websocket_server_options.tls_client_ca,
+                                              cert_reqs=client_cert_)
+                if _HAS_OPEN_SSL:
+                    ctx = OpenSSL.SSL.Context(OpenSSL.SSL.SSLv23_METHOD)
+                    ctx.use_privatekey_file(
+                        self.websocket_server_options.private_key)
+                    ctx.use_certificate_file(
+                        self.websocket_server_options.certificate)
+                    socket_ = OpenSSL.SSL.Connection(ctx, socket_)
+            self._sockets.append((socket_, addrinfo))
+
+    def server_bind(self):
+        """Override SocketServer.TCPServer.server_bind to enable multiple
+        sockets bind.
+        """
+
+        failed_sockets = []
+
+        for socketinfo in self._sockets:
+            socket_, addrinfo = socketinfo
+            if self.allow_reuse_address:
+                socket_.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            try:
+                socket_.bind(self.server_address)
+            except Exception, e:
+                self._logger.info('Skip by failure: %r', e)
+                socket_.close()
+                failed_sockets.append(socketinfo)
+            if self.server_address[1] == 0:
+                # The operating system assigns the actual port number for port
+                # number 0. This case, the second and later sockets should use
+                # the same port number. Also self.server_port is rewritten
+                # because it is exported, and will be used by external code.
+                self.server_address = (
+                    self.server_name, socket_.getsockname()[1])
+                self.server_port = self.server_address[1]
+                self._logger.info('Port %r is assigned', self.server_port)
+
+        for socketinfo in failed_sockets:
+            self._sockets.remove(socketinfo)
+
+    def server_activate(self):
+        """Override SocketServer.TCPServer.server_activate to enable multiple
+        sockets listen.
+        """
+
+        failed_sockets = []
+
+        for socketinfo in self._sockets:
+            socket_, addrinfo = socketinfo
+            self._logger.debug('Listen on: %r', addrinfo)
+            try:
+                socket_.listen(self.request_queue_size)
+            except Exception, e:
+                self._logger.info('Skip by failure: %r', e)
+                socket_.close()
+                failed_sockets.append(socketinfo)
+
+        for socketinfo in failed_sockets:
+            self._sockets.remove(socketinfo)
+
+        if len(self._sockets) == 0:
+            self._logger.critical(
+                'No sockets activated. Use info log level to see the reason.')
+
+    def server_close(self):
+        """Override SocketServer.TCPServer.server_close to enable multiple
+        sockets close.
+        """
+
+        for socketinfo in self._sockets:
+            socket_, addrinfo = socketinfo
+            self._logger.info('Close on: %r', addrinfo)
+            socket_.close()
+
+    def fileno(self):
+        """Override SocketServer.TCPServer.fileno."""
+
+        self._logger.critical('Not supported: fileno')
+        return self._sockets[0][0].fileno()
+
+    def handle_error(self, rquest, client_address):
+        """Override SocketServer.handle_error."""
+
+        self._logger.error(
+            'Exception in processing request from: %r\n%s',
+            client_address,
+            util.get_stack_trace())
+        # Note: client_address is a tuple.
+
+    def get_request(self):
+        """Override TCPServer.get_request to wrap OpenSSL.SSL.Connection
+        object with _StandaloneSSLConnection to provide makefile method. We
+        cannot substitute OpenSSL.SSL.Connection.makefile since it's readonly
+        attribute.
+        """
+
+        accepted_socket, client_address = self.socket.accept()
+        if self.websocket_server_options.use_tls and _HAS_OPEN_SSL:
+            accepted_socket = _StandaloneSSLConnection(accepted_socket)
+        return accepted_socket, client_address
+
+    def serve_forever(self, poll_interval=0.5):
+        """Override SocketServer.BaseServer.serve_forever."""
+
+        self.__ws_serving = True
+        self.__ws_is_shut_down.clear()
+        handle_request = self.handle_request
+        if hasattr(self, '_handle_request_noblock'):
+            handle_request = self._handle_request_noblock
+        else:
+            self._logger.warning('Fallback to blocking request handler')
+        try:
+            while self.__ws_serving:
+                r, w, e = select.select(
+                    [socket_[0] for socket_ in self._sockets],
+                    [], [], poll_interval)
+                for socket_ in r:
+                    self.socket = socket_
+                    handle_request()
+                self.socket = None
+        finally:
+            self.__ws_is_shut_down.set()
+
+    def shutdown(self):
+        """Override SocketServer.BaseServer.shutdown."""
+
+        self.__ws_serving = False
+        self.__ws_is_shut_down.wait()
+
+
+class WebSocketRequestHandler(CGIHTTPServer.CGIHTTPRequestHandler):
+    """CGIHTTPRequestHandler specialized for WebSocket."""
+
+    # Use httplib.HTTPMessage instead of mimetools.Message.
+    MessageClass = httplib.HTTPMessage
+
+    def setup(self):
+        """Override SocketServer.StreamRequestHandler.setup to wrap rfile
+        with MemorizingFile.
+
+        This method will be called by BaseRequestHandler's constructor
+        before calling BaseHTTPRequestHandler.handle.
+        BaseHTTPRequestHandler.handle will call
+        BaseHTTPRequestHandler.handle_one_request and it will call
+        WebSocketRequestHandler.parse_request.
+        """
+
+        # Call superclass's setup to prepare rfile, wfile, etc. See setup
+        # definition on the root class SocketServer.StreamRequestHandler to
+        # understand what this does.
+        CGIHTTPServer.CGIHTTPRequestHandler.setup(self)
+
+        self.rfile = memorizingfile.MemorizingFile(
+            self.rfile,
+            max_memorized_lines=_MAX_MEMORIZED_LINES)
+
+    def __init__(self, request, client_address, server):
+        self._logger = util.get_class_logger(self)
+
+        self._options = server.websocket_server_options
+
+        # Overrides CGIHTTPServerRequestHandler.cgi_directories.
+        self.cgi_directories = self._options.cgi_directories
+        # Replace CGIHTTPRequestHandler.is_executable method.
+        if self._options.is_executable_method is not None:
+            self.is_executable = self._options.is_executable_method
+
+        # This actually calls BaseRequestHandler.__init__.
+        CGIHTTPServer.CGIHTTPRequestHandler.__init__(
+            self, request, client_address, server)
+
+    def parse_request(self):
+        """Override BaseHTTPServer.BaseHTTPRequestHandler.parse_request.
+
+        Return True to continue processing for HTTP(S), False otherwise.
+
+        See BaseHTTPRequestHandler.handle_one_request method which calls
+        this method to understand how the return value will be handled.
+        """
+
+        # We hook parse_request method, but also call the original
+        # CGIHTTPRequestHandler.parse_request since when we return False,
+        # CGIHTTPRequestHandler.handle_one_request continues processing and
+        # it needs variables set by CGIHTTPRequestHandler.parse_request.
+        #
+        # Variables set by this method will be also used by WebSocket request
+        # handling (self.path, self.command, self.requestline, etc. See also
+        # how _StandaloneRequest's members are implemented using these
+        # attributes).
+        if not CGIHTTPServer.CGIHTTPRequestHandler.parse_request(self):
+            return False
+
+        if self._options.use_basic_auth:
+            auth = self.headers.getheader('Authorization')
+            if auth != self._options.basic_auth_credential:
+                self.send_response(401)
+                self.send_header('WWW-Authenticate',
+                                 'Basic realm="Pywebsocket"')
+                self.end_headers()
+                self._logger.info('Request basic authentication')
+                return True
+
+        host, port, resource = http_header_util.parse_uri(self.path)
+        if resource is None:
+            self._logger.info('Invalid URI: %r', self.path)
+            self._logger.info('Fallback to CGIHTTPRequestHandler')
+            return True
+        server_options = self.server.websocket_server_options
+        if host is not None:
+            validation_host = server_options.validation_host
+            if validation_host is not None and host != validation_host:
+                self._logger.info('Invalid host: %r (expected: %r)',
+                                  host,
+                                  validation_host)
+                self._logger.info('Fallback to CGIHTTPRequestHandler')
+                return True
+        if port is not None:
+            validation_port = server_options.validation_port
+            if validation_port is not None and port != validation_port:
+                self._logger.info('Invalid port: %r (expected: %r)',
+                                  port,
+                                  validation_port)
+                self._logger.info('Fallback to CGIHTTPRequestHandler')
+                return True
+        self.path = resource
+
+        request = _StandaloneRequest(self, self._options.use_tls)
+
+        try:
+            # Fallback to default http handler for request paths for which
+            # we don't have request handlers.
+            if not self._options.dispatcher.get_handler_suite(self.path):
+                self._logger.info('No handler for resource: %r',
+                                  self.path)
+                self._logger.info('Fallback to CGIHTTPRequestHandler')
+                return True
+        except dispatch.DispatchException, e:
+            self._logger.info('%s', e)
+            self.send_error(e.status)
+            return False
+
+        # If any Exceptions without except clause setup (including
+        # DispatchException) is raised below this point, it will be caught
+        # and logged by WebSocketServer.
+
+        try:
+            try:
+                handshake.do_handshake(
+                    request,
+                    self._options.dispatcher,
+                    allowDraft75=self._options.allow_draft75,
+                    strict=self._options.strict)
+            except handshake.VersionException, e:
+                self._logger.info('%s', e)
+                self.send_response(common.HTTP_STATUS_BAD_REQUEST)
+                self.send_header(common.SEC_WEBSOCKET_VERSION_HEADER,
+                                 e.supported_versions)
+                self.end_headers()
+                return False
+            except handshake.HandshakeException, e:
+                # Handshake for ws(s) failed.
+                self._logger.info('%s', e)
+                self.send_error(e.status)
+                return False
+
+            request._dispatcher = self._options.dispatcher
+            self._options.dispatcher.transfer_data(request)
+        except handshake.AbortedByUserException, e:
+            self._logger.info('%s', e)
+        return False
+
+    def log_request(self, code='-', size='-'):
+        """Override BaseHTTPServer.log_request."""
+
+        self._logger.info('"%s" %s %s',
+                          self.requestline, str(code), str(size))
+
+    def log_error(self, *args):
+        """Override BaseHTTPServer.log_error."""
+
+        # Despite the name, this method is for warnings than for errors.
+        # For example, HTTP status code is logged by this method.
+        self._logger.warning('%s - %s',
+                             self.address_string(),
+                             args[0] % args[1:])
+
+    def is_cgi(self):
+        """Test whether self.path corresponds to a CGI script.
+
+        Add extra check that self.path doesn't contains ..
+        Also check if the file is a executable file or not.
+        If the file is not executable, it is handled as static file or dir
+        rather than a CGI script.
+        """
+
+        if CGIHTTPServer.CGIHTTPRequestHandler.is_cgi(self):
+            if '..' in self.path:
+                return False
+                # strip query parameter from request path
+            resource_name = self.path.split('?', 2)[0]
+            # convert resource_name into real path name in filesystem.
+            scriptfile = self.translate_path(resource_name)
+            if not os.path.isfile(scriptfile):
+                return False
+            if not self.is_executable(scriptfile):
+                return False
+            return True
+        return False
+
+
+def _get_logger_from_class(c):
+    return logging.getLogger('%s.%s' % (c.__module__, c.__name__))
+
+
+def _configure_logging(options):
+    logging.addLevelName(common.LOGLEVEL_FINE, 'FINE')
+
+    logger = logging.getLogger()
+    logger.setLevel(logging.getLevelName(options.log_level.upper()))
+    if options.log_file:
+        handler = logging.handlers.RotatingFileHandler(
+            options.log_file, 'a', options.log_max, options.log_count)
+    else:
+        handler = logging.StreamHandler()
+    formatter = logging.Formatter(
+        '[%(asctime)s] [%(levelname)s] %(name)s: %(message)s')
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+
+    deflate_log_level_name = logging.getLevelName(
+        options.deflate_log_level.upper())
+    _get_logger_from_class(util._Deflater).setLevel(
+        deflate_log_level_name)
+    _get_logger_from_class(util._Inflater).setLevel(
+        deflate_log_level_name)
+
+class DefaultOptions:
+    server_host = ''
+    port = common.DEFAULT_WEB_SOCKET_PORT
+    use_tls = False
+    private_key = ''
+    certificate = ''
+    ca_certificate = ''
+    dispatcher = None
+    request_queue_size = _DEFAULT_REQUEST_QUEUE_SIZE
+    use_basic_auth = False
+
+    allow_draft75 = False
+    strict = False
+    validation_host = None
+    validation_port = None
+    cgi_directories = ''
+    is_executable_method = False
+
+def _main(args=None):
+    """You can call this function from your own program, but please note that
+    this function has some side-effects that might affect your program. For
+    example, util.wrap_popen3_for_win use in this method replaces implementation
+    of os.popen3.
+    """
+
+    options, args = _parse_args_and_config(args=args)
+
+    os.chdir(options.document_root)
+
+    _configure_logging(options)
+
+    # TODO(tyoshino): Clean up initialization of CGI related values. Move some
+    # of code here to WebSocketRequestHandler class if it's better.
+    options.cgi_directories = []
+    options.is_executable_method = None
+    if options.cgi_paths:
+        options.cgi_directories = options.cgi_paths.split(',')
+        if sys.platform in ('cygwin', 'win32'):
+            cygwin_path = None
+            # For Win32 Python, it is expected that CYGWIN_PATH
+            # is set to a directory of cygwin binaries.
+            # For example, websocket_server.py in Chromium sets CYGWIN_PATH to
+            # full path of third_party/cygwin/bin.
+            if 'CYGWIN_PATH' in os.environ:
+                cygwin_path = os.environ['CYGWIN_PATH']
+            util.wrap_popen3_for_win(cygwin_path)
+
+            def __check_script(scriptpath):
+                return util.get_script_interp(scriptpath, cygwin_path)
+
+            options.is_executable_method = __check_script
+
+    if options.use_tls:
+        if not (_HAS_SSL or _HAS_OPEN_SSL):
+            logging.critical('TLS support requires ssl or pyOpenSSL module.')
+            sys.exit(1)
+        if not options.private_key or not options.certificate:
+            logging.critical(
+                'To use TLS, specify private_key and certificate.')
+            sys.exit(1)
+
+    if options.tls_client_auth:
+        if not options.use_tls:
+            logging.critical('TLS must be enabled for client authentication.')
+            sys.exit(1)
+        if not _HAS_SSL:
+            logging.critical('Client authentication requires ssl module.')
+
+    if not options.scan_dir:
+        options.scan_dir = options.websock_handlers
+
+    if options.use_basic_auth:
+        options.basic_auth_credential = 'Basic ' + base64.b64encode(
+            options.basic_auth_credential)
+
+    try:
+        if options.thread_monitor_interval_in_sec > 0:
+            # Run a thread monitor to show the status of server threads for
+            # debugging.
+            ThreadMonitor(options.thread_monitor_interval_in_sec).start()
+
+        server = WebSocketServer(options)
+        server.serve_forever()
+    except Exception, e:
+        logging.critical('mod_pywebsocket: %s' % e)
+        logging.critical('mod_pywebsocket: %s' % util.get_stack_trace())
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    _main(sys.argv[1:])
+
+
+# vi:sts=4 sw=4 et
diff --git a/module/remote/wsbackend/__init__.py b/module/remote/wsbackend/__init__.py
new file mode 100644
index 000000000..de6d13128
--- /dev/null
+++ b/module/remote/wsbackend/__init__.py
@@ -0,0 +1,2 @@
+__author__ = 'christian'
+  
\ No newline at end of file
diff --git a/module/setup/System_Checks.py b/module/setup/System_Checks.py
new file mode 100644
index 000000000..cef46956b
--- /dev/null
+++ b/module/setup/System_Checks.py
@@ -0,0 +1,126 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+    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/>.
+    
+    @author: RaNaN
+"""
+from getpass import getpass
+import module.common.pylgettext as gettext
+import os
+from os import makedirs
+from os.path import abspath, dirname, exists, join
+from subprocess import PIPE, call
+import sys
+from sys import exit
+from module.utils import get_console_encoding
+
+class System_Checks():
+    def __init__(self):
+        self.result = ""
+
+    def print_str(self, text, translate = True):
+        if translate:
+            self.result += _(text) + "\n"
+        else:
+            self.result += text + "\n"
+
+    def print_dep(self, name, value):
+        """Print Status of dependency"""
+        if value:
+            self.print_str(name + ": OK", False)
+        else:
+            self.print_str(name + ": missing", False)
+
+    def check_basic(self):
+        self.result = "" #clear result
+        python = False
+        if sys.version_info[:2] > (2, 7):
+            self.print_str("Your python version is to new, Please use Python 2.6/2.7")
+        elif sys.version_info[:2] < (2, 5):
+            self.print_str("Your python version is to old, Please use at least Python 2.5")
+        else:
+            self.print_str("Python Version: OK")
+            python = True
+
+        curl = self.check_module("pycurl")
+        self.print_dep("pycurl", curl)
+
+        sqlite = self.check_module("sqlite3")
+        self.print_dep("sqlite3", sqlite)
+
+        beaker = self.check_module("beaker")
+        self.print_dep("beaker", beaker)
+
+        jinja = True
+        try:
+            import jinja2
+            v = jinja2.__version__
+            if v and "unknown" not in v:
+                if not v.startswith("2.5") and not v.startswith("2.6"):
+                    self.print_str("Your installed jinja2 version %s seems too old.") % jinja2.__version__
+                    self.print_str("You can safely continue but if the webinterface is not working,")
+                    self.print_str("please upgrade or deinstall it, pyLoad includes a sufficient jinja2 library.")
+                    jinja = False
+        except:
+            pass
+        self.print_dep("jinja2", jinja)
+        
+        return self.result, (python and curl and sqlite and (beaker or jinja))
+
+    def check_ssl(self):
+        self.result = "" #clear result
+        ssl = self.check_module("OpenSSL")
+        self.print_dep("py-OpenSSL", ssl)
+        return self.result, ssl
+
+    def check_crypto(self):
+        self.result = "" #clear result
+        crypto = self.check_module("Crypto")
+        self.print_dep("pycrypto", crypto)
+        return self.result, crypto
+
+    def check_captcha(self):
+        self.result = "" #clear result
+        pil = self.check_module("Image")
+        self.print_dep("py-imaging", pil)
+        if os.name == "nt":
+            tesser = self.check_prog([join(pypath, "tesseract", "tesseract.exe"), "-v"])
+        else:
+            tesser = self.check_prog(["tesseract", "-v"])
+        self.print_dep("tesseract", tesser)
+        return self.result, pil and tesser
+
+    def check_js(self):
+        self.result = "" #clear result
+        from module.common import JsEngine
+        js = True if JsEngine.ENGINE else False
+        self.print_dep(_("JS engine"), js)
+        return self.result, pil and tesser
+
+    def check_module(self, module):
+        try:
+            __import__(module)
+            return True
+        except:
+            return False
+
+    def check_prog(self, command):
+        pipe = PIPE
+        try:
+            call(command, stdout=pipe, stderr=pipe)
+            return True
+        except:
+            return False
+        
diff --git a/module/threads/AddonThread.py b/module/threads/AddonThread.py
new file mode 100644
index 000000000..afb56f66b
--- /dev/null
+++ b/module/threads/AddonThread.py
@@ -0,0 +1,65 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from copy import copy
+from traceback import print_exc
+
+from BaseThread import BaseThread
+
+class AddonThread(BaseThread):
+    """thread for addons"""
+
+    def __init__(self, m, function, args, kwargs):
+        """Constructor"""
+        BaseThread.__init__(self, m)
+
+        self.f = function
+        self.args = args
+        self.kwargs = kwargs
+
+        self.active = []
+
+        m.localThreads.append(self)
+
+        self.start()
+
+    def getActiveFiles(self):
+        return self.active
+
+    def addActive(self, pyfile):
+        """ Adds a pyfile to active list and thus will be displayed on overview"""
+        if pyfile not in self.active:
+            self.active.append(pyfile)
+
+    def finishFile(self, pyfile):
+        if pyfile in self.active:
+            self.active.remove(pyfile)
+
+        pyfile.finishIfDone()
+
+    def run(self): #TODO: approach via func_code
+        try:
+            try:
+                self.kwargs["thread"] = self
+                self.f(*self.args, **self.kwargs)
+            except TypeError, e:
+                #dirty method to filter out exceptions
+                if "unexpected keyword argument 'thread'" not in e.args[0]:
+                    raise
+
+                del self.kwargs["thread"]
+                self.f(*self.args, **self.kwargs)
+        except Exception, e:
+            if hasattr(self.f, "im_self"):
+                addon = self.f.im_self
+                addon.logError(_("An Error occurred"), e)
+                if self.m.core.debug:
+                    print_exc()
+                    self.writeDebugReport(addon.__name__, plugin=addon)
+
+        finally:
+            local = copy(self.active)
+            for x in local:
+                self.finishFile(x)
+
+            self.m.localThreads.remove(self)
\ No newline at end of file
diff --git a/module/threads/BaseThread.py b/module/threads/BaseThread.py
new file mode 100644
index 000000000..c64678a72
--- /dev/null
+++ b/module/threads/BaseThread.py
@@ -0,0 +1,142 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from threading import Thread
+from time import strftime, gmtime
+from sys import exc_info
+from types import MethodType
+from pprint import pformat
+from traceback import format_exc
+
+from module.utils import primary_uid
+from module.utils.fs import listdir, join, save_join, stat, exists
+
+class BaseThread(Thread):
+    """abstract base class for thread types"""
+
+    def __init__(self, manager):
+        Thread.__init__(self)
+        self.setDaemon(True)
+        self.m = manager #thread manager
+        self.core = manager.core
+        self.log = manager.core.log
+
+        #: Owner of the thread, every type should set it
+        self.owner = None
+
+    @property
+    def user(self):
+        return primary_uid(self.owner)
+
+    def getProgress(self):
+        """ retrieves progress information about the current running task
+
+        :return: :class:`ProgressInfo`
+        """
+
+    # Debug Stuff
+    def writeDebugReport(self, name, pyfile=None, plugin=None):
+        """ writes a debug report to disk  """
+
+        dump_name = "debug_%s_%s.zip" % (name, strftime("%d-%m-%Y_%H-%M-%S"))
+        if pyfile:
+            dump = self.getFileDump(pyfile)
+        else:
+            dump = self.getPluginDump(plugin)
+
+        try:
+            import zipfile
+
+            zip = zipfile.ZipFile(dump_name, "w")
+
+            if exists(join("tmp", name)):
+                for f in listdir(join("tmp", name)):
+                    try:
+                        # avoid encoding errors
+                        zip.write(join("tmp", name, f), save_join(name, f))
+                    except:
+                        pass
+
+            info = zipfile.ZipInfo(save_join(name, "debug_Report.txt"), gmtime())
+            info.external_attr = 0644 << 16L # change permissions
+            zip.writestr(info, dump)
+
+            info = zipfile.ZipInfo(save_join(name, "system_Report.txt"), gmtime())
+            info.external_attr = 0644 << 16L
+            zip.writestr(info, self.getSystemDump())
+
+            zip.close()
+
+            if not stat(dump_name).st_size:
+                raise Exception("Empty Zipfile")
+
+        except Exception, e:
+            self.log.debug("Error creating zip file: %s" % e)
+
+            dump_name = dump_name.replace(".zip", ".txt")
+            f = open(dump_name, "wb")
+            f.write(dump)
+            f.close()
+
+        self.log.info("Debug Report written to %s" % dump_name)
+        return dump_name
+
+    def getFileDump(self, pyfile):
+        dump = "pyLoad %s Debug Report of %s %s \n\nTRACEBACK:\n %s \n\nFRAMESTACK:\n" % (
+            self.m.core.api.getServerVersion(), pyfile.pluginname, pyfile.plugin.__version__, format_exc())
+
+        tb = exc_info()[2]
+        stack = []
+        while tb:
+            stack.append(tb.tb_frame)
+            tb = tb.tb_next
+
+        for frame in stack[1:]:
+            dump += "\nFrame %s in %s at line %s\n" % (frame.f_code.co_name,
+                                                       frame.f_code.co_filename,
+                                                       frame.f_lineno)
+
+            for key, value in frame.f_locals.items():
+                dump += "\t%20s = " % key
+                try:
+                    dump += pformat(value) + "\n"
+                except Exception, e:
+                    dump += "<ERROR WHILE PRINTING VALUE> " + str(e) + "\n"
+
+            del frame
+
+        del stack #delete it just to be sure...
+
+        dump += "\n\nPLUGIN OBJECT DUMP: \n\n"
+
+        for name in dir(pyfile.plugin):
+            attr = getattr(pyfile.plugin, name)
+            if not name.endswith("__") and type(attr) != MethodType:
+                dump += "\t%20s = " % name
+                try:
+                    dump += pformat(attr) + "\n"
+                except Exception, e:
+                    dump += "<ERROR WHILE PRINTING VALUE> " + str(e) + "\n"
+
+        dump += "\nPYFILE OBJECT DUMP: \n\n"
+
+        for name in dir(pyfile):
+            attr = getattr(pyfile, name)
+            if not name.endswith("__") and type(attr) != MethodType:
+                dump += "\t%20s = " % name
+                try:
+                    dump += pformat(attr) + "\n"
+                except Exception, e:
+                    dump += "<ERROR WHILE PRINTING VALUE> " + str(e) + "\n"
+
+        dump += "\n\nCONFIG: \n\n"
+        dump += pformat(self.m.core.config.values) + "\n"
+
+        return dump
+
+        #TODO
+    def getPluginDump(self, plugin):
+        return ""
+
+    def getSystemDump(self):
+        return ""
diff --git a/module/threads/DecrypterThread.py b/module/threads/DecrypterThread.py
new file mode 100644
index 000000000..39448a620
--- /dev/null
+++ b/module/threads/DecrypterThread.py
@@ -0,0 +1,81 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from time import sleep
+from traceback import print_exc
+
+from module.utils import uniqify
+from module.plugins.Base import Retry
+from module.plugins.Crypter import Package
+
+from BaseThread import BaseThread
+
+class DecrypterThread(BaseThread):
+    """thread for decrypting"""
+
+    def __init__(self, manager, data, pid):
+        """constructor"""
+        BaseThread.__init__(self, manager)
+        self.data = data
+        self.pid = pid
+
+        self.start()
+
+    def run(self):
+        plugin_map = {}
+        for url, plugin in self.data:
+            if plugin in plugin_map:
+                plugin_map[plugin].append(url)
+            else:
+                plugin_map[plugin] = [url]
+
+        self.decrypt(plugin_map)
+
+    def decrypt(self, plugin_map):
+        pack = self.m.core.files.getPackage(self.pid)
+        result = []
+
+        for name, urls in plugin_map.iteritems():
+            klass = self.m.core.pluginManager.loadClass("crypter", name)
+            plugin = klass(self.m.core, pack, pack.password)
+            plugin_result = []
+
+            try:
+                try:
+                    plugin_result = plugin._decrypt(urls)
+                except Retry:
+                    sleep(1)
+                    plugin_result = plugin._decrypt(urls)
+            except Exception, e:
+                plugin.logError(_("Decrypting failed"), e)
+                if self.m.core.debug:
+                    print_exc()
+                    self.writeDebugReport(plugin.__name__, plugin=plugin)
+
+            plugin.logDebug("Decrypted", plugin_result)
+            result.extend(plugin_result)
+
+        #TODO
+        result = uniqify(result)
+        pack_names = {}
+        urls = []
+
+        for p in result:
+            if isinstance(p, Package):
+                if p.name in pack_names:
+                    pack_names[p.name].urls.extend(p.urls)
+                else:
+                    pack_names[p.name] = p
+            else:
+                urls.append(p)
+
+        if urls:
+            self.log.info(_("Decrypted %(count)d links into package %(name)s") % {"count": len(urls), "name": pack.name})
+            self.m.core.api.addFiles(self.pid, urls)
+
+        for p in pack_names.itervalues():
+            self.m.core.api.addPackage(p.name, p.urls, pack.password)
+
+        if not result:
+            self.log.info(_("No links decrypted"))
+
diff --git a/module/threads/DownloadThread.py b/module/threads/DownloadThread.py
new file mode 100644
index 000000000..cf59c5639
--- /dev/null
+++ b/module/threads/DownloadThread.py
@@ -0,0 +1,231 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+    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/>.
+
+    @author: RaNaN
+"""
+
+from Queue import Queue
+from time import sleep, time
+from traceback import print_exc
+from sys import exc_clear
+from pycurl import error
+
+from module.plugins.Base import Fail, Retry, Abort
+from module.plugins.Hoster import Reconnect, SkipDownload
+from module.network.HTTPRequest import BadHeader
+
+from BaseThread import BaseThread
+
+class DownloadThread(BaseThread):
+    """thread for downloading files from 'real' hoster plugins"""
+
+    def __init__(self, manager):
+        """Constructor"""
+        BaseThread.__init__(self, manager)
+
+        self.queue = Queue() # job queue
+        self.active = None
+
+        self.start()
+
+    def run(self):
+        """run method"""
+        pyfile = None
+
+        while True:
+            del pyfile
+            self.active = self.queue.get()
+            pyfile = self.active
+
+            if self.active == "quit":
+                self.active = None
+                self.m.threads.remove(self)
+                return True
+
+            try:
+                if not pyfile.hasPlugin(): continue
+                #this pyfile was deleted while queuing
+
+                pyfile.plugin.checkForSameFiles(starting=True)
+                self.log.info(_("Download starts: %s" % pyfile.name))
+
+                # start download
+                self.core.addonManager.downloadPreparing(pyfile)
+                pyfile.plugin.preprocessing(self)
+
+                self.log.info(_("Download finished: %s") % pyfile.name)
+                self.core.addonManager.downloadFinished(pyfile)
+                self.core.files.checkPackageFinished(pyfile)
+
+            except NotImplementedError:
+                self.log.error(_("Plugin %s is missing a function.") % pyfile.pluginname)
+                pyfile.setStatus("failed")
+                pyfile.error = "Plugin does not work"
+                self.clean(pyfile)
+                continue
+
+            except Abort:
+                try:
+                    self.log.info(_("Download aborted: %s") % pyfile.name)
+                except:
+                    pass
+
+                pyfile.setStatus("aborted")
+
+                self.clean(pyfile)
+                continue
+
+            except Reconnect:
+                self.queue.put(pyfile)
+                #pyfile.req.clearCookies()
+
+                while self.m.reconnecting.isSet():
+                    sleep(0.5)
+
+                continue
+
+            except Retry, e:
+                reason = e.args[0]
+                self.log.info(_("Download restarted: %(name)s | %(msg)s") % {"name": pyfile.name, "msg": reason})
+                self.queue.put(pyfile)
+                continue
+            except Fail, e:
+                msg = e.args[0]
+
+                # TODO: activate former skipped downloads
+
+                if msg == "offline":
+                    pyfile.setStatus("offline")
+                    self.log.warning(_("Download is offline: %s") % pyfile.name)
+                elif msg == "temp. offline":
+                    pyfile.setStatus("temp. offline")
+                    self.log.warning(_("Download is temporary offline: %s") % pyfile.name)
+                else:
+                    pyfile.setStatus("failed")
+                    self.log.warning(_("Download failed: %(name)s | %(msg)s") % {"name": pyfile.name, "msg": msg})
+                    pyfile.error = msg
+
+                self.core.addonManager.downloadFailed(pyfile)
+                self.clean(pyfile)
+                continue
+
+            except error, e:
+                if len(e.args) == 2:
+                    code, msg = e.args
+                else:
+                    code = 0
+                    msg = e.args
+
+                self.log.debug("pycurl exception %s: %s" % (code, msg))
+
+                if code in (7, 18, 28, 52, 56):
+                    self.log.warning(_("Couldn't connect to host or connection reset, waiting 1 minute and retry."))
+                    wait = time() + 60
+
+                    pyfile.waitUntil = wait
+                    pyfile.setStatus("waiting")
+                    while time() < wait:
+                        sleep(1)
+                        if pyfile.abort:
+                            break
+
+                    if pyfile.abort:
+                        self.log.info(_("Download aborted: %s") % pyfile.name)
+                        pyfile.setStatus("aborted")
+
+                        self.clean(pyfile)
+                    else:
+                        self.queue.put(pyfile)
+
+                    continue
+
+                else:
+                    pyfile.setStatus("failed")
+                    self.log.error("pycurl error %s: %s" % (code, msg))
+                    if self.core.debug:
+                        print_exc()
+                        self.writeDebugReport(pyfile.plugin.__name__, pyfile)
+
+                    self.core.addonManager.downloadFailed(pyfile)
+
+                self.clean(pyfile)
+                continue
+
+            except SkipDownload, e:
+                pyfile.setStatus("skipped")
+
+                self.log.info(_("Download skipped: %(name)s due to %(plugin)s")
+                % {"name": pyfile.name, "plugin": e.message})
+
+                self.clean(pyfile)
+
+                self.core.files.checkPackageFinished(pyfile)
+
+                self.active = False
+                self.core.files.save()
+
+                continue
+
+
+            except Exception, e:
+                if isinstance(e, BadHeader) and e.code == 500:
+                    pyfile.setStatus("temp. offline")
+                    self.log.warning(_("Download is temporary offline: %s") % pyfile.name)
+                    pyfile.error = _("Internal Server Error")
+
+                else:
+                    pyfile.setStatus("failed")
+                    self.log.warning(_("Download failed: %(name)s | %(msg)s") % {"name": pyfile.name, "msg": str(e)})
+                    pyfile.error = str(e)
+
+                if self.core.debug:
+                    print_exc()
+                    self.writeDebugReport(pyfile.plugin.__name__, pyfile)
+
+                self.core.addonManager.downloadFailed(pyfile)
+                self.clean(pyfile)
+                continue
+
+            finally:
+                self.core.files.save()
+                pyfile.checkIfProcessed()
+                exc_clear()
+
+            
+            #pyfile.plugin.req.clean()
+
+            self.active = False
+            pyfile.finishIfDone()
+            self.core.files.save()
+
+    def getProgress(self):
+        if self.active:
+            return self.active.getProgressInfo()
+
+
+    def put(self, job):
+        """assign a job to the thread"""
+        self.queue.put(job)
+
+    def clean(self, pyfile):
+        """ set thread inactive and release pyfile """
+        self.active = False
+        pyfile.release()
+
+    def stop(self):
+        """stops the thread"""
+        self.put("quit")
diff --git a/module/threads/InfoThread.py b/module/threads/InfoThread.py
new file mode 100644
index 000000000..a8a2c6e7e
--- /dev/null
+++ b/module/threads/InfoThread.py
@@ -0,0 +1,168 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from time import time
+from traceback import print_exc
+
+from module.Api import LinkStatus
+from module.common.packagetools import parseNames
+from module.utils import has_method, accumulate
+
+from BaseThread import BaseThread
+
+class InfoThread(BaseThread):
+    def __init__(self, manager, data, pid=-1, rid=-1):
+        """Constructor"""
+        BaseThread.__init__(self, manager)
+
+        self.data = data
+        self.pid = pid # package id
+        # [ .. (name, plugin) .. ]
+
+        self.rid = rid #result id
+
+        self.cache = [] #accumulated data
+
+        self.start()
+
+    def run(self):
+        """run method"""
+
+        plugins = accumulate(self.data)
+        crypter = {}
+
+        # filter out crypter plugins
+        for name in self.m.core.pluginManager.getPlugins("crypter"):
+            if name in plugins:
+                crypter[name] = plugins[name]
+                del plugins[name]
+
+        #directly write to database
+        if self.pid > -1:
+            for pluginname, urls in plugins.iteritems():
+                plugin = self.m.core.pluginManager.getPluginModule(pluginname)
+                klass = self.m.core.pluginManager.getPluginClass(pluginname)
+                if has_method(klass, "getInfo"):
+                    self.fetchForPlugin(pluginname, klass, urls, self.updateDB)
+                    self.m.core.files.save()
+                elif has_method(plugin, "getInfo"):
+                    self.log.debug("Deprecated .getInfo() method on module level, use classmethod instead")
+                    self.fetchForPlugin(pluginname, plugin, urls, self.updateDB)
+                    self.m.core.files.save()
+
+        else: #post the results
+            for name, urls in crypter:
+                #attach container content
+                try:
+                    data = self.decrypt(name, urls)
+                except:
+                    print_exc()
+                    self.m.log.error("Could not decrypt container.")
+                    data = []
+
+                accumulate(data, plugins)
+
+            self.m.infoResults[self.rid] = {}
+
+            for pluginname, urls in plugins.iteritems():
+                plugin = self.m.core.pluginManager.getPlugin(pluginname, True)
+                klass = getattr(plugin, pluginname)
+                if has_method(klass, "getInfo"):
+                    self.fetchForPlugin(pluginname, plugin, urls, self.updateResult, True)
+                    #force to process cache
+                    if self.cache:
+                        self.updateResult(pluginname, [], True)
+                elif has_method(plugin, "getInfo"):
+                    self.log.debug("Deprecated .getInfo() method on module level, use staticmethod instead")
+                    self.fetchForPlugin(pluginname, plugin, urls, self.updateResult, True)
+                    #force to process cache
+                    if self.cache:
+                        self.updateResult(pluginname, [], True)
+                else:
+                    #generate default result
+                    result = [(url, 0, 3, url) for url in urls]
+
+                    self.updateResult(pluginname, result, True)
+
+            self.m.infoResults[self.rid]["ALL_INFO_FETCHED"] = {}
+
+        self.m.timestamp = time() + 5 * 60
+
+
+    def updateDB(self, plugin, result):
+        self.m.core.files.updateFileInfo(result, self.pid)
+
+    def updateResult(self, plugin, result, force=False):
+        #parse package name and generate result
+        #accumulate results
+
+        self.cache.extend(result)
+
+        if len(self.cache) >= 20 or force:
+            #used for package generating
+            tmp = [(name, (url, LinkStatus(name, plugin, "unknown", status, int(size))))
+            for name, size, status, url in self.cache]
+
+            data = parseNames(tmp)
+            result = {}
+            for k, v in data.iteritems():
+                for url, status in v:
+                    status.packagename = k
+                    result[url] = status
+
+            self.m.setInfoResults(self.rid, result)
+
+            self.cache = []
+
+    def updateCache(self, plugin, result):
+        self.cache.extend(result)
+
+    def fetchForPlugin(self, pluginname, plugin, urls, cb, err=None):
+        try:
+            result = [] #result loaded from cache
+            process = [] #urls to process
+            for url in urls:
+                if url in self.m.infoCache:
+                    result.append(self.m.infoCache[url])
+                else:
+                    process.append(url)
+
+            if result:
+                self.m.log.debug("Fetched %d values from cache for %s" % (len(result), pluginname))
+                cb(pluginname, result)
+
+            if process:
+                self.m.log.debug("Run Info Fetching for %s" % pluginname)
+                for result in plugin.getInfo(process):
+                    #result = [ .. (name, size, status, url) .. ]
+                    if not type(result) == list: result = [result]
+
+                    for res in result:
+                        self.m.infoCache[res[3]] = res
+
+                    cb(pluginname, result)
+
+            self.m.log.debug("Finished Info Fetching for %s" % pluginname)
+        except Exception, e:
+            self.m.log.warning(_("Info Fetching for %(name)s failed | %(err)s") %
+                               {"name": pluginname, "err": str(e)})
+            if self.m.core.debug:
+                print_exc()
+
+            # generate default results
+            if err:
+                result = [(url, 0, 3, url) for url in urls]
+                cb(pluginname, result)
+
+
+    def decrypt(self, plugin, urls):
+        self.m.log.debug("Pre decrypting %s" % plugin)
+        klass = self.m.core.pluginManager.loadClass("crypter", plugin)
+
+        # only decrypt files
+        if has_method(klass, "decryptFile"):
+            urls = klass.decrypt(urls)
+            data, crypter = self.m.core.pluginManager.parseUrls(urls)
+            return data
+
+        return []
diff --git a/module/ThreadManager.py b/module/threads/ThreadManager.py
index 8937f4a29..f67179d08 100644
--- a/module/ThreadManager.py
+++ b/module/threads/ThreadManager.py
@@ -1,22 +1,20 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-"""
-    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/>.
-
-    @author: RaNaN
-"""
+###############################################################################
+#   Copyright(c) 2008-2012 pyLoad Team
+#   http://www.pyload.org
+#
+#   This file is part of pyLoad.
+#   pyLoad is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU Affero General Public License as
+#   published by the Free Software Foundation, either version 3 of the
+#   License, or (at your option) any later version.
+#
+#   Subjected to the terms and conditions in LICENSE
+#
+#   @author: RaNaN
+###############################################################################
 
 from os.path import exists, join
 import re
@@ -28,11 +26,14 @@ from random import choice
 
 import pycurl
 
-import PluginThread
-from module.PyFile import PyFile
+from module.datatypes.PyFile import PyFile
 from module.network.RequestFactory import getURL
-from module.utils import freeSpace, lock
+from module.utils import lock, uniqify
+from module.utils.fs import free_space
 
+from DecrypterThread import DecrypterThread
+from DownloadThread import DownloadThread
+from InfoThread import InfoThread
 
 class ThreadManager:
     """manages the download threads, assign jobs, reconnect etc"""
@@ -44,7 +45,7 @@ class ThreadManager:
         self.log = core.log
 
         self.threads = []  # thread list
-        self.localThreads = []  #hook+decrypter threads
+        self.localThreads = []  #addon+decrypter threads
 
         self.pause = True
 
@@ -63,42 +64,43 @@ class ThreadManager:
 
         # threads which are fetching hoster results
         self.infoResults = {}
-        #timeout for cache purge
+        # timeout for cache purge
         self.timestamp = 0
 
         pycurl.global_init(pycurl.GLOBAL_DEFAULT)
 
-        for i in range(0, self.core.config.get("download", "max_downloads")):
+        for i in range(self.core.config.get("download", "max_downloads")):
             self.createThread()
 
 
     def createThread(self):
         """create a download thread"""
 
-        thread = PluginThread.DownloadThread(self)
+        thread = DownloadThread(self)
         self.threads.append(thread)
 
     def createInfoThread(self, data, pid):
-        """
-        start a thread whichs fetches online status and other infos
-        data = [ .. () .. ]
-        """
+        """ start a thread which fetches online status and other info's """
         self.timestamp = time() + 5 * 60
-
-        PluginThread.InfoThread(self, data, pid)
+        if data: InfoThread(self, data, pid)
 
     @lock
-    def createResultThread(self, data, add=False):
+    def createResultThread(self, data):
         """ creates a thread to fetch online status, returns result id """
         self.timestamp = time() + 5 * 60
 
         rid = self.resultIDs
         self.resultIDs += 1
 
-        PluginThread.InfoThread(self, data, rid=rid, add=add)
+        InfoThread(self, data, rid=rid)
 
         return rid
 
+    @lock
+    def createDecryptThread(self, data, pid):
+        """ Start decrypting of entered data, all links in one package are accumulated to one thread."""
+        if data: DecrypterThread(self, data, pid)
+
 
     @lock
     def getInfoResult(self, rid):
@@ -116,8 +118,25 @@ class ThreadManager:
     def setInfoResults(self, rid, result):
         self.infoResults[rid].update(result)
 
+    def getActiveDownloads(self, user=None):
+        # TODO: user context
+        return [x.active for x in self.threads if x.active and isinstance(x.active, PyFile)]
+
+    def getProgressList(self, user=None):
+        info = []
+
+        # TODO: local threads can create multiple progresses
+        for thread in self.threads + self.localThreads:
+            # skip if not belong to current user
+            if user and thread.user != user: continue
+
+            progress = thread.getProgress()
+            if progress: info.append(progress)
+
+        return info
+
     def getActiveFiles(self):
-        active = [x.active for x in self.threads if x.active and isinstance(x.active, PyFile)]
+        active = self.getActiveDownloads()
 
         for t in self.localThreads:
             active.extend(t.getActiveFiles())
@@ -128,24 +147,22 @@ class ThreadManager:
         """get a id list of all pyfiles processed"""
         return [x.id for x in self.getActiveFiles()]
 
-
     def work(self):
-        """run all task which have to be done (this is for repetivive call by core)"""
+        """run all task which have to be done (this is for repetetive call by core)"""
         try:
             self.tryReconnect()
         except Exception, e:
             self.log.error(_("Reconnect Failed: %s") % str(e) )
             self.reconnecting.clear()
-            if self.core.debug:
-                print_exc()
+            self.core.print_exc()
+
         self.checkThreadCount()
 
         try:
             self.assignJob()
         except Exception, e:
             self.log.warning("Assign job error", e)
-            if self.core.debug:
-                print_exc()
+            self.core.print_exc()
             
             sleep(0.5)
             self.assignJob()
@@ -156,7 +173,6 @@ class ThreadManager:
             self.infoResults.clear()
             self.log.debug("Cleared Result cache")
 
-    #----------------------------------------------------------------------
     def tryReconnect(self):
         """checks if reconnect needed"""
 
@@ -186,7 +202,7 @@ class ThreadManager:
 
         ip = self.getIP()
 
-        self.core.hookManager.beforeReconnecting(ip)
+        self.core.addonManager.beforeReconnecting(ip)
 
         self.log.debug("Old IP: %s" % ip)
 
@@ -203,7 +219,7 @@ class ThreadManager:
         reconn.wait()
         sleep(1)
         ip = self.getIP()
-        self.core.hookManager.afterReconnecting(ip)
+        self.core.addonManager.afterReconnecting(ip)
 
         self.log.info(_("Reconnected, new IP: %s") % ip)
 
@@ -227,9 +243,8 @@ class ThreadManager:
 
         return ip
 
-    #----------------------------------------------------------------------
     def checkThreadCount(self):
-        """checks if there are need for increasing or reducing thread count"""
+        """checks if there is a need for increasing or reducing thread count"""
 
         if len(self.threads) == self.core.config.get("download", "max_downloads"):
             return True
@@ -242,7 +257,7 @@ class ThreadManager:
 
 
     def cleanPycurl(self):
-        """ make a global curl cleanup (currently ununused) """
+        """ make a global curl cleanup (currently unused) """
         if self.processingIds():
             return False
         pycurl.global_cleanup()
@@ -251,9 +266,9 @@ class ThreadManager:
         self.log.debug("Cleaned up pycurl")
         return True
 
-    #----------------------------------------------------------------------
+
     def assignJob(self):
-        """assing a job to a thread if possible"""
+        """assign a job to a thread if possible"""
 
         if self.pause or not self.core.api.isTimeDownload(): return
 
@@ -262,14 +277,10 @@ class ThreadManager:
 
         free = [x for x in self.threads if not x.active]
 
-        inuse = set([(x.active.pluginname,self.getLimit(x)) for x in self.threads if x.active and x.active.hasPlugin() and x.active.plugin.account])
-        inuse = map(lambda x : (x[0], x[1], len([y for y in self.threads if y.active and y.active.pluginname == x[0]])) ,inuse)
-        onlimit = [x[0] for x in inuse if x[1] > 0 and x[2] >= x[1]]
-
-        occ = [x.active.pluginname for x in self.threads if x.active and x.active.hasPlugin() and not x.active.plugin.multiDL] + onlimit
+        inuse = [(x.active.pluginname, x.active.plugin.getDownloadLimit()) for x in self.threads if x.active and x.active.hasPlugin()]
+        inuse = [(x[0], x[1], len([y for y in self.threads if y.active and y.active.pluginname == x[0]])) for x in inuse]
+        occ = tuple(sorted(uniqify([x[0] for x in inuse if 0 < x[1] <= x[2]])))
         
-        occ.sort()
-        occ = tuple(set(occ))
         job = self.core.files.getJob(occ)
         if job:
             try:
@@ -282,36 +293,20 @@ class ThreadManager:
                 job.release()
                 return
 
-            if job.plugin.__type__ == "hoster":
-                spaceLeft = freeSpace(self.core.config["general"]["download_folder"]) / 1024 / 1024
-                if spaceLeft < self.core.config["general"]["min_free_space"]:
-                    self.log.warning(_("Not enough space left on device"))
-                    self.pause = True
-
-                if free and not self.pause:
-                    thread = free[0]
-                    #self.downloaded += 1
-
-                    thread.put(job)
-                else:
-                    #put job back
-                    if occ not in self.core.files.jobCache:
-                        self.core.files.jobCache[occ] = []
-                    self.core.files.jobCache[occ].append(job.id)
-
-                    #check for decrypt jobs
-                    job = self.core.files.getDecryptJob()
-                    if job:
-                        job.initPlugin()
-                        thread = PluginThread.DecrypterThread(self, job)
-
+            spaceLeft = free_space(self.core.config["general"]["download_folder"]) / 1024 / 1024
+            if spaceLeft < self.core.config["general"]["min_free_space"]:
+                self.log.warning(_("Not enough space left on device"))
+                self.pause = True
 
+            if free and not self.pause:
+                thread = free[0]
+                #self.downloaded += 1
+                thread.put(job)
             else:
-                thread = PluginThread.DecrypterThread(self, job)
-
-    def getLimit(self, thread):
-        limit = thread.active.plugin.account.getAccountData(thread.active.plugin.user)["options"].get("limitDL",["0"])[0]
-        return int(limit)
+                #put job back
+                if occ not in self.core.files.jobCache:
+                    self.core.files.jobCache[occ] = []
+                self.core.files.jobCache[occ].append(job.id)
 
     def cleanup(self):
         """do global cleanup, should be called when finished with pycurl"""
diff --git a/module/plugins/hooks/__init__.py b/module/threads/__init__.py
index e69de29bb..e69de29bb 100644
--- a/module/plugins/hooks/__init__.py
+++ b/module/threads/__init__.py
diff --git a/module/unescape.py b/module/unescape.py
deleted file mode 100644
index d8999e077..000000000
--- a/module/unescape.py
+++ /dev/null
@@ -1,3 +0,0 @@
-from module.utils import html_unescape
-#deprecated
-unescape = html_unescape
\ No newline at end of file
diff --git a/module/utils.py b/module/utils.py
deleted file mode 100644
index 8748b7693..000000000
--- a/module/utils.py
+++ /dev/null
@@ -1,201 +0,0 @@
-# -*- coding: utf-8 -*-
-
-""" Store all usefull functions here """
-
-import os
-import sys
-import time
-import re
-from os.path import join
-from string import maketrans
-from htmlentitydefs import name2codepoint
-
-def chmod(*args):
-    try:
-        os.chmod(*args)
-    except:
-        pass
-
-
-def decode(string):
-    """ decode string with utf if possible """
-    try:
-        return string.decode("utf8", "replace")
-    except:
-        return string
-
-
-def remove_chars(string, repl):
-    """ removes all chars in repl from string"""
-    if type(string) == str:
-        return string.translate(maketrans("", ""), repl)
-    elif type(string) == unicode:
-        return string.translate(dict([(ord(s), None) for s in repl]))
-
-
-def save_path(name):
-    #remove some chars
-    if os.name == 'nt':
-        return remove_chars(name, '/\\?%*:|"<>')
-    else:
-        return remove_chars(name, '/\\"')
-
-
-def save_join(*args):
-    """ joins a path, encoding aware """
-    return fs_encode(join(*[x if type(x) == unicode else decode(x) for x in args]))
-
-
-# File System Encoding functions:
-# Use fs_encode before accesing files on disk, it will encode the string properly
-
-if sys.getfilesystemencoding().startswith('ANSI'):
-    def fs_encode(string):
-        try:
-            string = string.encode('utf-8')
-        finally:
-            return string
-
-    fs_decode = decode #decode utf8
-
-else:
-    fs_encode = fs_decode = lambda x: x  # do nothing
-
-def get_console_encoding(enc):
-    if os.name == "nt": 
-        if enc == "cp65001": # aka UTF-8
-            print "WARNING: Windows codepage 65001 is not supported."
-            enc = "cp850"
-    else:
-        enc = "utf8"
-    
-    return enc
-
-def compare_time(start, end):
-    start = map(int, start)
-    end = map(int, end)
-
-    if start == end: return True
-
-    now = list(time.localtime()[3:5])
-    if start < now < end: return True
-    elif start > end and (now > start or now < end): return True
-    elif start < now > end < start: return True
-    else: return False
-
-
-def formatSize(size):
-    """formats size of bytes"""
-    size = int(size)
-    steps = 0
-    sizes = ["B", "KiB", "MiB", "GiB", "TiB"]
-    while size > 1000:
-        size /= 1024.0
-        steps += 1
-    return "%.2f %s" % (size, sizes[steps])
-
-
-def formatSpeed(speed):
-    return formatSize(speed) + "/s"
-
-
-def freeSpace(folder):
-    if os.name == "nt":
-        import ctypes
-
-        free_bytes = ctypes.c_ulonglong(0)
-        ctypes.windll.kernel32.GetDiskFreeSpaceExW(ctypes.c_wchar_p(folder), None, None, ctypes.pointer(free_bytes))
-        return free_bytes.value
-    else:
-        from os import statvfs
-
-        s = statvfs(folder)
-        return s.f_bsize * s.f_bavail
-
-
-def uniqify(seq, idfun=None):
-# order preserving
-    if idfun is None:
-        def idfun(x): return x
-    seen = {}
-    result = []
-    for item in seq:
-        marker = idfun(item)
-        # in old Python versions:
-        # if seen.has_key(marker)
-        # but in new ones:
-        if marker in seen: continue
-        seen[marker] = 1
-        result.append(item)
-    return result
-
-
-def parseFileSize(string, unit=None): #returns bytes
-    if not unit:
-        m = re.match(r"(\d*[\.,]?\d+)(.*)", string.strip().lower())
-        if m:
-            traffic = float(m.group(1).replace(",", "."))
-            unit = m.group(2)
-        else:
-            return 0
-    else:
-        if isinstance(string, basestring):
-            traffic = float(string.replace(",", "."))
-        else:
-            traffic = string
-
-    #ignore case
-    unit = unit.lower().strip()
-
-    if unit in ("gb", "gig", "gbyte", "gigabyte", "gib", "g"):
-        traffic *= 1 << 30
-    elif unit in ("mb", "mbyte", "megabyte", "mib", "m"):
-        traffic *= 1 << 20
-    elif unit in ("kb", "kib", "kilobyte", "kbyte", "k"):
-        traffic *= 1 << 10
-
-    return traffic
-
-
-def lock(func):
-    def new(*args):
-        #print "Handler: %s args: %s" % (func,args[1:])
-        args[0].lock.acquire()
-        try:
-            return func(*args)
-        finally:
-            args[0].lock.release()
-
-    return new
-
-
-def fixup(m):
-    text = m.group(0)
-    if text[:2] == "&#":
-        # character reference
-        try:
-            if text[:3] == "&#x":
-                return unichr(int(text[3:-1], 16))
-            else:
-                return unichr(int(text[2:-1]))
-        except ValueError:
-            pass
-    else:
-        # named entity
-        try:
-            name = text[1:-1]
-            text = unichr(name2codepoint[name])
-        except KeyError:
-            pass
-
-    return text # leave as is
-
-
-def html_unescape(text):
-    """Removes HTML or XML character references and entities from a text string"""
-    return re.sub("&#?\w+;", fixup, text)
-
-if __name__ == "__main__":
-    print freeSpace(".")
-
-    print remove_chars("ab'cdgdsf''ds'", "'ghd")
diff --git a/module/utils/__init__.py b/module/utils/__init__.py
new file mode 100644
index 000000000..901f553e7
--- /dev/null
+++ b/module/utils/__init__.py
@@ -0,0 +1,253 @@
+# -*- coding: utf-8 -*-
+
+""" Store all usefull functions here """
+
+import os
+import time
+import re
+from string import maketrans
+from itertools import islice
+from htmlentitydefs import name2codepoint
+
+# abstraction layer for json operations
+try: # since python 2.6
+    import json
+except ImportError: #use system simplejson if available
+    import simplejson as json
+
+json_loads = json.loads
+json_dumps = json.dumps
+
+def decode(string):
+    """ decode string with utf if possible """
+    try:
+        if type(string) == str:
+            return string.decode("utf8", "replace")
+        else:
+            return string
+    except:
+        return string
+
+def encode(string):
+    """ decode string to utf if possible """
+    try:
+        if type(string) == unicode:
+            return string.encode("utf8", "replace")
+        else:
+            return string
+    except:
+        return string
+
+def remove_chars(string, repl):
+    """ removes all chars in repl from string"""
+    if type(string) == str:
+        return string.translate(maketrans("", ""), repl)
+    elif type(string) == unicode:
+        return string.translate(dict([(ord(s), None) for s in repl]))
+
+
+def get_console_encoding(enc):
+    if os.name == "nt": 
+        if enc == "cp65001": # aka UTF-8
+            print "WARNING: Windows codepage 65001 is not supported."
+            enc = "cp850"
+    else:
+        enc = "utf8"
+    
+    return enc
+
+def compare_time(start, end):
+    start = map(int, start)
+    end = map(int, end)
+
+    if start == end: return True
+
+    now = list(time.localtime()[3:5])
+    if start < now < end: return True
+    elif start > end and (now > start or now < end): return True
+    elif start < now > end < start: return True
+    else: return False
+
+def to_list(value):
+    return value if type(value) == list else ([value] if value is not None else [])
+
+def formatSize(size):
+    print "Deprecated formatSize, use format_size"
+    return format_size(size)
+
+def format_size(bytes):
+    bytes = int(bytes)
+    steps = 0
+    sizes = ("B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB")
+    while bytes > 1000:
+        bytes /= 1024.0
+        steps += 1
+    return "%.2f %s" % (bytes, sizes[steps])
+
+def formatSpeed(speed):
+    print "Deprecated formatSpeed, use format_speed"
+    return format_speed(speed)
+
+def format_speed(speed):
+    return format_size(speed) + "/s"
+
+def format_time(seconds):
+    if seconds < 0: return "00:00:00"
+    hours, seconds = divmod(seconds, 3600)
+    minutes, seconds = divmod(seconds, 60)
+    return "%.2i:%.2i:%.2i" % (hours, minutes, seconds)
+
+def uniqify(seq): #by Dave Kirby
+    """ removes duplicates from list, preserve order """
+    seen = set()
+    return [x for x in seq if x not in seen and not seen.add(x)]
+
+def bits_set(bits, compare):
+    """ checks if all bits are set in compare, or bits is 0 """
+    return bits == (bits & compare)
+
+def parseFileSize(string, unit=None): #returns bytes
+    if not unit:
+        m = re.match(r"(\d*[\.,]?\d+)(.*)", string.strip().lower())
+        if m:
+            traffic = float(m.group(1).replace(",", "."))
+            unit = m.group(2)
+        else:
+            return 0
+    else:
+        if isinstance(string, basestring):
+            traffic = float(string.replace(",", "."))
+        else:
+            traffic = string
+
+    #ignore case
+    unit = unit.lower().strip()
+
+    if unit in ("gb", "gig", "gbyte", "gigabyte", "gib", "g"):
+        traffic *= 1 << 30
+    elif unit in ("mb", "mbyte", "megabyte", "mib", "m"):
+        traffic *= 1 << 20
+    elif unit in ("kb", "kib", "kilobyte", "kbyte", "k"):
+        traffic *= 1 << 10
+
+    return traffic
+
+
+def lock(func):
+    def new(*args, **kwargs):
+        #print "Handler: %s args: %s" % (func,args[1:])
+        args[0].lock.acquire()
+        try:
+            return func(*args, **kwargs)
+        finally:
+            args[0].lock.release()
+
+    return new
+
+def read_lock(func):
+    def new(*args, **kwargs):
+        args[0].lock.acquire(shared=True)
+        try:
+            return func(*args, **kwargs)
+        finally:
+            args[0].lock.release()
+
+    return new
+
+def chunks(iterable, size):
+    it = iter(iterable)
+    item = list(islice(it, size))
+    while item:
+        yield item
+        item = list(islice(it, size))
+
+
+def fixup(m):
+    text = m.group(0)
+    if text[:2] == "&#":
+        # character reference
+        try:
+            if text[:3] == "&#x":
+                return unichr(int(text[3:-1], 16))
+            else:
+                return unichr(int(text[2:-1]))
+        except ValueError:
+            pass
+    else:
+        # named entity
+        try:
+            name = text[1:-1]
+            text = unichr(name2codepoint[name])
+        except KeyError:
+            pass
+
+    return text # leave as is
+
+
+def has_method(obj, name):
+    """ checks if 'name' was defined in obj, (false if it was inhereted) """
+    return name in obj.__dict__
+
+def accumulate(it, inv_map=None):
+    """ accumulate (key, value) data to {value : [keylist]} dictionary """
+    if not inv_map:
+        inv_map = {}
+
+    for key, value in it:
+        if value in inv_map:
+            inv_map[value].append(key)
+        else:
+            inv_map[value] = [key]
+
+    return inv_map
+
+def to_string(value):
+    return str(value) if not isinstance(value, basestring) else value
+
+def to_int(string, default=0):
+    """ return int from string or default """
+    try:
+        return int(string)
+    except ValueError:
+        return default
+
+def from_string(value, typ=None):
+    """ cast value to given type, unicode for strings """
+
+    # value is no string
+    if not isinstance(value, basestring):
+        return value
+
+    value = decode(value)
+
+    if typ == "int":
+        return int(value)
+    elif typ == "bool":
+        return True if value.lower() in ("1", "true", "on", "an", "yes") else False
+    elif typ == "time":
+        if not value: value = "0:00"
+        if not ":" in value: value += ":00"
+        return value
+    else:
+        return value
+
+def get_index(l, value):
+    """ .index method that also works on tuple and python 2.5 """
+    for pos, t in enumerate(l):
+        if t == value:
+            return pos
+
+    # Matches behavior of list.index
+    raise ValueError("list.index(x): x not in list")
+
+def primary_uid(user):
+    """ Gets primary user id for user instances or ints """
+    if type(user) == int: return user
+    return user.primary if user else None
+
+def html_unescape(text):
+    """Removes HTML or XML character references and entities from a text string"""
+    return re.sub("&#?\w+;", fixup, text)
+
+if __name__ == "__main__":
+    print remove_chars("ab'cdgdsf''ds'", "'ghd")
diff --git a/module/utils/fs.py b/module/utils/fs.py
new file mode 100644
index 000000000..92cc605e7
--- /dev/null
+++ b/module/utils/fs.py
@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+
+import os
+import sys
+from os.path import join
+from . import decode, remove_chars
+
+# File System Encoding functions:
+# Use fs_encode before accessing files on disk, it will encode the string properly
+
+if sys.getfilesystemencoding().startswith('ANSI'):
+    def fs_encode(string):
+        if type(string) == unicode:
+            return string.encode('utf8')
+        return string
+
+    fs_decode = decode #decode utf8
+
+else:
+    fs_encode = fs_decode = lambda x: x  # do nothing
+
+# FS utilities
+def chmod(path, mode):
+    try:
+        return os.chmod(fs_encode(path), mode)
+    except :
+        pass
+
+def dirname(path):
+    return fs_decode(os.path.dirname(fs_encode(path)))
+
+def abspath(path):
+    return fs_decode(os.path.abspath(fs_encode(path)))
+
+def chown(path, uid, gid):
+    return os.chown(fs_encode(path), uid, gid)
+
+def remove(path):
+    return os.remove(fs_encode(path))
+
+def exists(path):
+    return os.path.exists(fs_encode(path))
+
+def makedirs(path, mode=0755):
+    return os.makedirs(fs_encode(path), mode)
+
+# fs_decode?
+def listdir(path):
+    return [fs_decode(x) for x in os.listdir(fs_encode(path))]
+
+def save_filename(name):
+    #remove some chars
+    if os.name == 'nt':
+        return remove_chars(name, '/\\?%*:|"<>,')
+    else:
+        return remove_chars(name, '/\\"')
+
+def stat(name):
+    return os.stat(fs_encode(name))
+
+def save_join(*args):
+    """ joins a path, encoding aware """
+    return fs_encode(join(*[x if type(x) == unicode else decode(x) for x in args]))
+
+def free_space(folder):
+    folder = fs_encode(folder)
+
+    if os.name == "nt":
+        import ctypes
+
+        free_bytes = ctypes.c_ulonglong(0)
+        ctypes.windll.kernel32.GetDiskFreeSpaceExW(ctypes.c_wchar_p(folder), None, None, ctypes.pointer(free_bytes))
+        return free_bytes.value
+    else:
+        from os import statvfs
+
+        s = statvfs(folder)
+        return s.f_frsize * s.f_bavail
diff --git a/module/web/ServerThread.py b/module/web/ServerThread.py
index 84667e5f6..a86ecca70 100644
--- a/module/web/ServerThread.py
+++ b/module/web/ServerThread.py
@@ -1,32 +1,44 @@
 #!/usr/bin/env python
 from __future__ import with_statement
-from os.path import exists
+from time import time, sleep
 
-import os
 import threading
 import logging
 
+from module.utils.fs import exists
+
 core = None
 setup = None
 log = logging.getLogger("log")
 
 class WebServer(threading.Thread):
-    def __init__(self, pycore):
-        global core
+    def __init__(self, pycore=None, pysetup=None):
+        global core, setup
         threading.Thread.__init__(self)
-        self.core = pycore
-        core = pycore
-        self.running = True
-        self.server = pycore.config['webinterface']['server']
-        self.https = pycore.config['webinterface']['https']
-        self.cert = pycore.config["ssl"]["cert"]
-        self.key = pycore.config["ssl"]["key"]
-        self.host = pycore.config['webinterface']['host']
-        self.port = pycore.config['webinterface']['port']
+
+        if pycore:
+            core = pycore
+            config = pycore.config
+        elif pysetup:
+            setup = pysetup
+            config = pysetup.config
+        else:
+            raise Exception("No config context provided")
+
+        self.server = config['webinterface']['server']
+        self.https = config['webinterface']['https']
+        self.cert = config["ssl"]["cert"]
+        self.key = config["ssl"]["key"]
+        self.host = config['webinterface']['host']
+        self.port = config['webinterface']['port']
+        self.debug = config['general']['debug_mode']
+        self.force_server = config['webinterface']['force_server']
+        self.error = None
 
         self.setDaemon(True)
 
     def run(self):
+        self.running = True
         import webinterface
         global webinterface
 
@@ -35,75 +47,97 @@ class WebServer(threading.Thread):
                 log.warning(_("SSL certificates not found."))
                 self.https = False
 
-        if self.server in ("lighttpd", "nginx"):
-            log.warning(_("Sorry, we dropped support for starting %s directly within pyLoad") % self.server)
-            log.warning(_("You can use the threaded server which offers good performance and ssl,"))
-            log.warning(_("of course you can still use your existing %s with pyLoads fastcgi server") % self.server)
-            log.warning(_("sample configs are located in the module/web/servers directory"))
-            self.server = "builtin"
+        prefer = None
+
+        # These cases covers all settings
+        if self.server == "threaded":
+            prefer = "threaded"
+        elif self.server == "fastcgi":
+            prefer = "flup"
+        elif self.server == "fallback":
+            prefer = "wsgiref"
+
+        server = self.select_server(prefer)
+
+        try:
+            self.start_server(server)
+
+        except Exception, e:
+            log.error(_("Failed starting webserver: " + e.message))
+            self.error = e
+            if core:
+                core.print_exc()
+
+    def select_server(self, prefer=None):
+        """ find a working server """
+        from servers import all_server
+
+        unavailable = []
+        server = None
+        for server in all_server:
+
+            if self.force_server and self.force_server == server.NAME:
+                break # Found server
+            # When force_server is set, no further checks have to be made
+            elif self.force_server:
+                continue
+
+            if prefer and prefer == server.NAME:
+                break # found prefered server
+            elif prefer: # prefer is similar to force, but force has precedence
+                continue
+
+            # Filter for server that offer ssl if needed
+            if self.https and not server.SSL:
+                continue
 
-        if self.server == "fastcgi":
-            try:
-                import flup
-            except:
-                log.warning(_("Can't use %(server)s, python-flup is not installed!") % {
-                    "server": self.server})
-                self.server = "builtin"
-        elif self.server == "lightweight":
             try:
-                import bjoern
+                if server.find():
+                    break # Found a server
+                else:
+                    unavailable.append(server.NAME)
             except Exception, e:
-                log.error(_("Error importing lightweight server: %s") % e)
-                log.warning(_("You need to download and compile bjoern, https://github.com/jonashaag/bjoern"))
-                log.warning(_("Copy the boern.so to module/lib folder or use setup.py install"))
-                log.warning(_("Of course you need to be familiar with linux and know how to compile software"))
-                self.server = "builtin"
-
-        if os.name == "nt":
-            self.core.log.info(_("Server set to threaded, due to known performance problems on windows."))
-            self.core.config['webinterface']['server'] = "threaded"
-            self.server = "threaded"
-
-
-        if self.server == "fastcgi":
-            self.start_fcgi()
-        elif self.server == "threaded":
-            self.start_threaded()
-        elif self.server == "lightweight":
-            self.start_lightweight()
-        else:
-            self.start_builtin()
+                log.error(_("Failed importing webserver: " + e.message))
 
-    def start_builtin(self):
+        if unavailable: # Just log whats not available to have some debug information
+            log.debug("Unavailable webserver: " + ",".join(unavailable))
 
-        if self.https:
-            log.warning(_("This server offers no SSL, please consider using threaded instead"))
+        if not server and self.force_server:
+            server = self.force_server # just return the name
 
-        self.core.log.info(_("Starting builtin webserver: %(host)s:%(port)d") % {"host": self.host, "port": self.port})
-        webinterface.run_simple(host=self.host, port=self.port)
+        return server
 
-    def start_threaded(self):
-        if self.https:
-            self.core.log.info(_("Starting threaded SSL webserver: %(host)s:%(port)d") % {"host": self.host, "port": self.port})
-        else:
-            self.cert = ""
-            self.key = ""
-            self.core.log.info(_("Starting threaded webserver: %(host)s:%(port)d") % {"host": self.host, "port": self.port})
 
-        webinterface.run_threaded(host=self.host, port=self.port, cert=self.cert, key=self.key)
+    def start_server(self, server):
 
-    def start_fcgi(self):
+        from servers import ServerAdapter
 
-        self.core.log.info(_("Starting fastcgi server: %(host)s:%(port)d") % {"host": self.host, "port": self.port})
-        webinterface.run_fcgi(host=self.host, port=self.port)
+        if issubclass(server, ServerAdapter):
+
+            if self.https and not server.SSL:
+                log.warning(_("This server offers no SSL, please consider using threaded instead"))
+            elif not self.https:
+                self.cert = self.key = None # This implicitly disables SSL
+                # there is no extra argument for the server adapter
+                # TODO: check for openSSL ?
+
+            # Now instantiate the serverAdapter
+            server = server(self.host, self.port, self.key, self.cert, 6, self.debug) # todo, num_connections
+            name = server.NAME
+
+        else: # server is just a string
+            name = server
+
+        log.info(_("Starting %(name)s webserver: %(host)s:%(port)d") % {"name": name, "host": self.host, "port": self.port})
+        webinterface.run_server(host=self.host, port=self.port, server=server)
 
 
-    def start_lightweight(self):
-        if self.https:
-            log.warning(_("This server offers no SSL, please consider using threaded instead"))
 
-        self.core.log.info(_("Starting lightweight webserver (bjoern): %(host)s:%(port)d") % {"host": self.host, "port": self.port})
-        webinterface.run_lightweight(host=self.host, port=self.port)
+    # check if an error was raised for n seconds
+    def check_error(self, n=1):
+        t = time() + n
+        while time() < t:
+            if self.error:
+                return self.error
+            sleep(0.1)
 
-    def quit(self):
-        self.running = False
diff --git a/module/web/api_app.py b/module/web/api_app.py
index 1629c1677..52903e92b 100644
--- a/module/web/api_app.py
+++ b/module/web/api_app.py
@@ -5,41 +5,43 @@ from urllib import unquote
 from itertools import chain
 from traceback import format_exc, print_exc
 
-from bottle import route, request, response, HTTPError
+from bottle import route, request, response, HTTPError, parse_auth
 
-from utils import toDict, set_session
+from utils import set_session, get_user_api
 from webinterface import PYLOAD
 
-from module.common.json_layer import json
-from module.lib.SafeEval import const_eval as literal_eval
-from module.Api import BaseObject
-
-# json encoder that accepts TBase objects
-class TBaseEncoder(json.JSONEncoder):
-
-    def default(self, o):
-        if isinstance(o, BaseObject):
-            return toDict(o)
-        return json.JSONEncoder.default(self, o)
+from module.Api import ExceptionObject
+from module.remote.json_converter import loads, dumps
+from module.utils import remove_chars
 
+def add_header(r):
+    r.headers.replace("Content-type", "application/json")
+    r.headers.append("Cache-Control", "no-cache, must-revalidate")
+    r.headers.append("Access-Control-Allow-Origin", "*")  # allow xhr requests
 
 # accepting positional arguments, as well as kwargs via post and get
-
-@route("/api/:func:args#[a-zA-Z0-9\-_/\"'\[\]%{}]*#")
-@route("/api/:func:args#[a-zA-Z0-9\-_/\"'\[\]%{}]*#", method="POST")
+# only forbidden path symbol are "?", which is used to separate GET data and #
+@route("/api/<func><args:re:[^#?]*>")
+@route("/api/<func><args:re:[^#?]*>", method="POST")
 def call_api(func, args=""):
-    response.headers.replace("Content-type", "application/json")
-    response.headers.append("Cache-Control", "no-cache, must-revalidate")
+    add_header(response)
 
     s = request.environ.get('beaker.session')
+    auth = parse_auth(request.get_header('Authorization', ''))
     if 'session' in request.POST:
-        s = s.get_by_id(request.POST['session'])
+        # removes "' so it works on json strings
+        s = s.get_by_id(remove_chars(request.POST['session'], "'\""))
+    elif auth:
+        user = PYLOAD.checkAuth(auth[0], auth[1], request.environ.get('REMOTE_ADDR', None))
+        # if auth is correct create a pseudo session
+        if user: s = {'uid': user.uid}
 
-    if not s or not s.get("authenticated", False):
-        return HTTPError(403, json.dumps("Forbidden"))
+    api = get_user_api(s)
+    if not api:
+        return HTTPError(403, dumps("Forbidden"))
 
-    if not PYLOAD.isAuthorized(func, {"role": s["role"], "permission": s["perms"]}):
-        return HTTPError(401, json.dumps("Unauthorized"))
+    if not PYLOAD.isAuthorized(func, api.user):
+        return HTTPError(401, dumps("Unauthorized"))
 
     args = args.split("/")[1:]
     kwargs = {}
@@ -49,54 +51,62 @@ def call_api(func, args=""):
         kwargs[x] = unquote(y)
 
     try:
-        return callApi(func, *args, **kwargs)
+        return callApi(api, func, *args, **kwargs)
+    except ExceptionObject, e:
+        return HTTPError(400, dumps(e))
     except Exception, e:
         print_exc()
-        return HTTPError(500, json.dumps({"error": e.message, "traceback": format_exc()}))
+        return HTTPError(500, dumps({"error": e.message, "traceback": format_exc()}))
 
+# TODO Better error codes on invalid input
 
-def callApi(func, *args, **kwargs):
+def callApi(api, func, *args, **kwargs):
     if not hasattr(PYLOAD.EXTERNAL, func) or func.startswith("_"):
         print "Invalid API call", func
-        return HTTPError(404, json.dumps("Not Found"))
+        return HTTPError(404, dumps("Not Found"))
 
-    result = getattr(PYLOAD, func)(*[literal_eval(x) for x in args],
-                                   **dict([(x, literal_eval(y)) for x, y in kwargs.iteritems()]))
+    # TODO: accept same payload as WS backends, combine into json_converter
+    # TODO: arguments as json dictionaries
+    # TODO: encoding
+    result = getattr(api, func)(*[loads(x) for x in args],
+                                   **dict([(x, loads(y)) for x, y in kwargs.iteritems()]))
 
-    # null is invalid json  response
+    # null is invalid json response
     if result is None: result = True
 
-    return json.dumps(result, cls=TBaseEncoder)
+    return dumps(result)
 
 
 #post -> username, password
 @route("/api/login", method="POST")
 def login():
-    response.headers.replace("Content-type", "application/json")
-    response.headers.append("Cache-Control", "no-cache, must-revalidate")
+    add_header(response)
 
-    user = request.forms.get("username")
+    username = request.forms.get("username")
     password = request.forms.get("password")
 
-    info = PYLOAD.checkAuth(user, password)
+    user = PYLOAD.checkAuth(username, password, request.environ.get('REMOTE_ADDR', None))
 
-    if not info:
-        return json.dumps(False)
+    if not user:
+        return dumps(False)
 
-    s = set_session(request, info)
+    s = set_session(request, user)
 
     # get the session id by dirty way, documentations seems wrong
     try:
         sid = s._headers["cookie_out"].split("=")[1].split(";")[0]
-        return json.dumps(sid)
+        return dumps(sid)
     except:
-        return json.dumps(True)
+        print "Could not get session"
+        return dumps(True)
 
 
 @route("/api/logout")
+@route("/api/logout", method="POST")
 def logout():
-    response.headers.replace("Content-type", "application/json")
-    response.headers.append("Cache-Control", "no-cache, must-revalidate")
+    add_header(response)
 
     s = request.environ.get('beaker.session')
     s.delete()
+
+    return dumps(True)
diff --git a/module/web/cnl_app.py b/module/web/cnl_app.py
index d8f7c1180..b6a98a0a8 100644
--- a/module/web/cnl_app.py
+++ b/module/web/cnl_app.py
@@ -6,6 +6,8 @@ from urllib import unquote
 from base64 import standard_b64decode
 from binascii import unhexlify
 
+from module.utils.fs import save_filename
+
 from bottle import route, request, HTTPError
 from webinterface import PYLOAD, DL_ROOT, JS
 
@@ -18,7 +20,7 @@ except:
 def local_check(function):
     def _view(*args, **kwargs):
         if request.environ.get('REMOTE_ADDR', "0") in ('127.0.0.1', 'localhost') \
-        or request.environ.get('HTTP_HOST','0') == '127.0.0.1:9666':
+        or request.environ.get('HTTP_HOST','0') in ('127.0.0.1:9666', 'localhost:9666'):
             return function(*args, **kwargs)
         else:
             return HTTPError(403, "Forbidden")
@@ -53,7 +55,7 @@ def addcrypted():
     package = request.forms.get('referer', 'ClickAndLoad Package')
     dlc = request.forms['crypted'].replace(" ", "+")
 
-    dlc_path = join(DL_ROOT, package.replace("/", "").replace("\\", "").replace(":", "") + ".dlc")
+    dlc_path = join(DL_ROOT, save_filename(package) + ".dlc")
     dlc_file = open(dlc_path, "wb")
     dlc_file.write(dlc)
     dlc_file.close()
diff --git a/module/web/filters.py b/module/web/filters.py
deleted file mode 100644
index 13b8345fc..000000000
--- a/module/web/filters.py
+++ /dev/null
@@ -1,62 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-import os
-from os.path import abspath, commonprefix, join
-
-quotechar = "::/"
-
-try:
-    from os.path import relpath
-except:
-    from posixpath import curdir, sep, pardir
-    def relpath(path, start=curdir):
-        """Return a relative version of a path"""
-        if not path:
-            raise ValueError("no path specified")
-        start_list = abspath(start).split(sep)
-        path_list = abspath(path).split(sep)
-        # Work out how much of the filepath is shared by start and path.
-        i = len(commonprefix([start_list, path_list]))
-        rel_list = [pardir] * (len(start_list)-i) + path_list[i:]
-        if not rel_list:
-            return curdir
-        return join(*rel_list)
-
-
-def quotepath(path):
-    try:
-        return path.replace("../", quotechar)
-    except AttributeError:
-        return path
-    except:
-        return ""
-
-def unquotepath(path):
-    try:
-        return path.replace(quotechar, "../")
-    except AttributeError:
-        return path
-    except:
-        return ""
-
-def path_make_absolute(path):
-    p = os.path.abspath(path)
-    if p[-1] == os.path.sep:
-        return p
-    else:
-        return p + os.path.sep
-
-def path_make_relative(path):
-    p = relpath(path)
-    if p[-1] == os.path.sep:
-        return p
-    else:
-        return p + os.path.sep
-
-def truncate(value, n):
-    if (n - len(value)) < 3:
-        return value[:n]+"..."
-    return value
-
-def date(date, format):
-    return date
\ No newline at end of file
diff --git a/module/web/json_app.py b/module/web/json_app.py
deleted file mode 100644
index f3626405c..000000000
--- a/module/web/json_app.py
+++ /dev/null
@@ -1,312 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-from os.path import join
-from traceback import print_exc
-from shutil import copyfileobj
-
-from bottle import route, request, HTTPError
-
-from webinterface import PYLOAD
-
-from utils import login_required, render_to_response, toDict
-
-from module.utils import decode, formatSize
-
-
-def format_time(seconds):
-    seconds = int(seconds)
-
-    hours, seconds = divmod(seconds, 3600)
-    minutes, seconds = divmod(seconds, 60)
-    return "%.2i:%.2i:%.2i" % (hours, minutes, seconds)
-
-
-def get_sort_key(item):
-    return item["order"]
-
-
-@route("/json/status")
-@route("/json/status", method="POST")
-@login_required('LIST')
-def status():
-    try:
-        status = toDict(PYLOAD.statusServer())
-        status['captcha'] = PYLOAD.isCaptchaWaiting()
-        return status
-    except:
-        return HTTPError()
-
-
-@route("/json/links")
-@route("/json/links", method="POST")
-@login_required('LIST')
-def links():
-    try:
-        links = [toDict(x) for x in PYLOAD.statusDownloads()]
-        ids = []
-        for link in links:
-            ids.append(link['fid'])
-
-            if link['status'] == 12:
-                link['info'] = "%s @ %s/s" % (link['format_eta'], formatSize(link['speed']))
-            elif link['status'] == 5:
-                link['percent'] = 0
-                link['size'] = 0
-                link['bleft'] = 0
-                link['info'] = _("waiting %s") % link['format_wait']
-            else:
-                link['info'] = ""
-
-        data = {'links': links, 'ids': ids}
-        return data
-    except Exception, e:
-        print_exc()
-        return HTTPError()
-
-
-@route("/json/packages")
-@login_required('LIST')
-def packages():
-    print "/json/packages"
-    try:
-        data = PYLOAD.getQueue()
-
-        for package in data:
-            package['links'] = []
-            for file in PYLOAD.get_package_files(package['id']):
-                package['links'].append(PYLOAD.get_file_info(file))
-
-        return data
-
-    except:
-        return HTTPError()
-
-
-@route("/json/package/<id:int>")
-@login_required('LIST')
-def package(id):
-    try:
-        data = toDict(PYLOAD.getPackageData(id))
-        data["links"] = [toDict(x) for x in data["links"]]
-
-        for pyfile in data["links"]:
-            if pyfile["status"] == 0:
-                pyfile["icon"] = "status_finished.png"
-            elif pyfile["status"] in (2, 3):
-                pyfile["icon"] = "status_queue.png"
-            elif pyfile["status"] in (9, 1):
-                pyfile["icon"] = "status_offline.png"
-            elif pyfile["status"] == 5:
-                pyfile["icon"] = "status_waiting.png"
-            elif pyfile["status"] == 8:
-                pyfile["icon"] = "status_failed.png"
-            elif pyfile["status"] == 4:
-                pyfile["icon"] = "arrow_right.png"
-            elif pyfile["status"] in (11, 13):
-                pyfile["icon"] = "status_proc.png"
-            else:
-                pyfile["icon"] = "status_downloading.png"
-
-        tmp = data["links"]
-        tmp.sort(key=get_sort_key)
-        data["links"] = tmp
-        return data
-
-    except:
-        print_exc()
-        return HTTPError()
-
-
-@route("/json/package_order/:ids")
-@login_required('ADD')
-def package_order(ids):
-    try:
-        pid, pos = ids.split("|")
-        PYLOAD.orderPackage(int(pid), int(pos))
-        return {"response": "success"}
-    except:
-        return HTTPError()
-
-
-@route("/json/abort_link/<id:int>")
-@login_required('DELETE')
-def abort_link(id):
-    try:
-        PYLOAD.stopDownloads([id])
-        return {"response": "success"}
-    except:
-        return HTTPError()
-
-
-@route("/json/link_order/:ids")
-@login_required('ADD')
-def link_order(ids):
-    try:
-        pid, pos = ids.split("|")
-        PYLOAD.orderFile(int(pid), int(pos))
-        return {"response": "success"}
-    except:
-        return HTTPError()
-
-
-@route("/json/add_package")
-@route("/json/add_package", method="POST")
-@login_required('ADD')
-def add_package():
-    name = request.forms.get("add_name", "New Package").strip()
-    queue = int(request.forms['add_dest'])
-    links = decode(request.forms['add_links'])
-    links = links.split("\n")
-    pw = request.forms.get("add_password", "").strip("\n\r")
-
-    try:
-        f = request.files['add_file']
-
-        if not name or name == "New Package":
-            name = f.name
-
-        fpath = join(PYLOAD.getConfigValue("general", "download_folder"), "tmp_" + f.filename)
-        destination = open(fpath, 'wb')
-        copyfileobj(f.file, destination)
-        destination.close()
-        links.insert(0, fpath)
-    except:
-        pass
-
-    name = name.decode("utf8", "ignore")
-
-    links = map(lambda x: x.strip(), links)
-    links = filter(lambda x: x != "", links)
-
-    pack = PYLOAD.addPackage(name, links, queue)
-    if pw:
-        pw = pw.decode("utf8", "ignore")
-        data = {"password": pw}
-        PYLOAD.setPackageData(pack, data)
-
-
-@route("/json/move_package/<dest:int>/<id:int>")
-@login_required('MODIFY')
-def move_package(dest, id):
-    try:
-        PYLOAD.movePackage(dest, id)
-        return {"response": "success"}
-    except:
-        return HTTPError()
-
-
-@route("/json/edit_package", method="POST")
-@login_required('MODIFY')
-def edit_package():
-    try:
-        id = int(request.forms.get("pack_id"))
-        data = {"name": request.forms.get("pack_name").decode("utf8", "ignore"),
-                "folder": request.forms.get("pack_folder").decode("utf8", "ignore"),
-                 "password": request.forms.get("pack_pws").decode("utf8", "ignore")}
-
-        PYLOAD.setPackageData(id, data)
-        return {"response": "success"}
-
-    except:
-        return HTTPError()
-
-
-@route("/json/set_captcha")
-@route("/json/set_captcha", method="POST")
-@login_required('ADD')
-def set_captcha():
-    if request.environ.get('REQUEST_METHOD', "GET") == "POST":
-        try:
-            PYLOAD.setCaptchaResult(request.forms["cap_id"], request.forms["cap_result"])
-        except:
-            pass
-
-    task = PYLOAD.getCaptchaTask()
-
-    if task.tid >= 0:
-        src = "data:image/%s;base64,%s" % (task.type, task.data)
-
-        return {'captcha': True, 'id': task.tid, 'src': src, 'result_type' : task.resultType}
-    else:
-        return {'captcha': False}
-
-
-@route("/json/load_config/:category/:section")
-@login_required("SETTINGS")
-def load_config(category, section):
-    conf = None
-    if category == "general":
-        conf = PYLOAD.getConfigDict()
-    elif category == "plugin":
-        conf = PYLOAD.getPluginConfigDict()
-
-    for key, option in conf[section].iteritems():
-        if key in ("desc","outline"): continue
-
-        if ";" in option["type"]:
-            option["list"] = option["type"].split(";")
-
-        option["value"] = decode(option["value"])
-
-    return render_to_response("settings_item.html", {"skey": section, "section": conf[section]})
-
-
-@route("/json/save_config/:category", method="POST")
-@login_required("SETTINGS")
-def save_config(category):
-    for key, value in request.POST.iteritems():
-        try:
-            section, option = key.split("|")
-        except:
-            continue
-
-        if category == "general": category = "core"
-
-        PYLOAD.setConfigValue(section, option, decode(value), category)
-
-
-@route("/json/add_account", method="POST")
-@login_required("ACCOUNTS")
-def add_account():
-    login = request.POST["account_login"]
-    password = request.POST["account_password"]
-    type = request.POST["account_type"]
-
-    PYLOAD.updateAccount(type, login, password)
-
-
-@route("/json/update_accounts", method="POST")
-@login_required("ACCOUNTS")
-def update_accounts():
-    deleted = [] #dont update deleted accs or they will be created again
-
-    for name, value in request.POST.iteritems():
-        value = value.strip()
-        if not value: continue
-        
-        tmp, user = name.split(";")
-        plugin, action = tmp.split("|")
-
-        if (plugin, user) in deleted: continue
-
-        if action == "password":
-            PYLOAD.updateAccount(plugin, user, value)
-        elif action == "time" and "-" in value:
-            PYLOAD.updateAccount(plugin, user, options={"time": [value]})
-        elif action == "limitdl" and value.isdigit():
-            PYLOAD.updateAccount(plugin, user, options={"limitDL": [value]})
-        elif action == "delete":
-            deleted.append((plugin,user))
-            PYLOAD.removeAccount(plugin, user)
-
-@route("/json/change_password", method="POST")
-def change_password():
-
-    user = request.POST["user_login"]
-    oldpw = request.POST["login_current_password"]
-    newpw = request.POST["login_new_password"]
-
-    if not PYLOAD.changePassword(user, oldpw, newpw):
-        print "Wrong password"
-        return HTTPError()
diff --git a/module/web/media/default/css/MooDialog.css b/module/web/media/default/css/MooDialog.css
deleted file mode 100644
index 48c9166ad..000000000
--- a/module/web/media/default/css/MooDialog.css
+++ /dev/null
@@ -1,92 +0,0 @@
-/* Created by Arian Stolwijk <http://www.aryweb.nl> */
-
-.MooDialog {
-/*	position: fixed;*/
-    margin: 0 auto 0 -350px;
-    width:600px;
-    padding:14px;
-    left:50%;
-    top: 100px;
-
-	position: absolute;
-	left: 50%;
-	z-index: 50000;
-
-	background: #eef5f8;
-	color: black;
-	border-radius: 7px;
-	-moz-border-radius: 7px;
-	-webkit-border-radius: 7px;
-	border-radius: 7px;
-	-moz-box-shadow: 1px 1px 5px rgba(0,0,0,0.8);
-	-webkit-box-shadow: 1px 1px 5px rgba(0,0,0,0.8);
-	box-shadow: 1px 1px 5px rgba(0,0,0,0.8);
-}
-
-.MooDialogTitle {
-	padding-top: 30px;
-}
-
-.MooDialog .title {
-	position: absolute;
-	top: 0;
-	left: 0;
-	right: 0;
-	padding: 3px 20px;
-	background: #b7c4dc;
-	border-bottom: 1px solid #a1aec5;
-	font-weight: bold;
-	text-shadow: 1px 1px 0 #fff;
-	color: black;
-	border-radius: 7px;
-	-moz-border-radius: 7px;
-	-webkit-border-radius: 7px;
-}
-
-.MooDialog .close {
-	background: url(/media/img/dialog-close.png) no-repeat;
-	width: 16px;
-	height: 16px;
-	display: block;
-	cursor: pointer;
-	top: -5px;
-	left: -5px;
-	position: absolute;
-}
-
-.MooDialog .buttons {
-	text-align: right;
-	margin: 0;
-	padding: 0;
-	border: 0;
-	background: none;
-}
-
-.MooDialog .iframe {
-	width: 100%;
-	height: 100%;
-}
-
-.MooDialog .textInput {
-	width: 200px;
-	float: left;
-}
-
-.MooDialog .MooDialogAlert,
-.MooDialog .MooDialogConfirm,
-.MooDialog .MooDialogPrompt,
-.MooDialog .MooDialogError {
-	background: url(/media/img/dialog-warning.png) no-repeat;
-	padding-left: 40px;
-	min-height: 40px;
-}
-
-.MooDialog .MooDialogConfirm,
-.MooDialog .MooDialogPromt {
-	background: url(/media/img/dialog-question.png) no-repeat;
-}
-
-.MooDialog .MooDialogError {
-	background: url(/media/img/dialog-error.png) no-repeat;
-}
-
diff --git a/module/web/media/default/css/default.css b/module/web/media/default/css/default.css
deleted file mode 100644
index fc0d148c2..000000000
--- a/module/web/media/default/css/default.css
+++ /dev/null
@@ -1,908 +0,0 @@
-.hidden {

-	display:none;

-}

-.leftalign {

-	text-align:left;

-}

-.centeralign {

-	text-align:center;

-}

-.rightalign {

-	text-align:right;

-}

-

-

-.dokuwiki div.plugin_translation ul li a.wikilink1:link, .dokuwiki div.plugin_translation ul li a.wikilink1:hover, .dokuwiki div.plugin_translation ul li a.wikilink1:active, .dokuwiki div.plugin_translation ul li a.wikilink1:visited {

-	background-color:#000080;

-	color:#fff !important;

-	text-decoration:none;

-	padding:0 0.2em;

-	margin:0.1em 0.2em;

-	border:none !important;

-}

-.dokuwiki div.plugin_translation ul li a.wikilink2:link, .dokuwiki div.plugin_translation ul li a.wikilink2:hover, .dokuwiki div.plugin_translation ul li a.wikilink2:active, .dokuwiki div.plugin_translation ul li a.wikilink2:visited {

-	background-color:#808080;

-	color:#fff !important;

-	text-decoration:none;

-	padding:0 0.2em;

-	margin:0.1em 0.2em;

-	border:none !important;

-}

-

-.dokuwiki div.plugin_translation ul li a:hover img {

-	opacity:1.0;

-	height:15px;

-}

-

-body {

-	margin:0;

-	padding:0;

-	background-color:white;

-	color:black;

-	font-size:12px;

-	font-family:Verdana, Helvetica, "Lucida Grande", Lucida, Arial, sans-serif;

-	font-family:sans-serif;

-	font-size:99, 96%;

-	font-size-adjust:none;

-	font-style:normal;

-	font-variant:normal;

-	font-weight:normal;

-	line-height:normal;

-}

-hr {

-	border-width:0;

-	border-bottom:1px #aaa dotted;

-}

-img {

-	border:none;

-}

-form {

-	margin:0px;

-	padding:0px;

-	border:none;

-	display:inline;

-	background:transparent;

-}

-ul li {

-	margin:5px;

-}

-textarea {

-	font-family:monospace;

-}

-table {

-	margin:0.5em 0;

-	border-collapse:collapse;

-}

-td {

-	padding:0.25em;

-	border:1pt solid #ADB9CC;

-}

-a {

-	color:#3465a4;

-	text-decoration:none;

-}

-a:hover {

-	text-decoration:underline;

-}

-

-option {

-	border:0 none #fff;

-}

-strong.highlight {

-	background-color:#fc9;

-	padding:1pt;

-}

-#pagebottom {

-	clear:both;

-}

-hr {

-	height:1px;

-	color:#c0c0c0;

-	background-color:#c0c0c0;

-	border:none;

-	margin:.2em 0 .2em 0;

-}

-

-.invisible {

-	margin:0px;

-	border:0px;

-	padding:0px;

-	height:0px;

-	visibility:hidden;

-}

-.left {

-	float:left !important;

-}

-.right {

-	float:right !important;

-}

-.center {

-	text-align:center;

-}

-div#body-wrapper {

-	padding:40px 40px 10px 40px;

-	font-size:127%;

-}

-div#content {

-	margin-top:-20px;

-	padding:0;

-	font-size:14px;

-	color:black;

-	line-height:1.5em;

-}

-h1, h2, h3, h4, h5, h6 {

-	background:transparent none repeat scroll 0 0;

-	border-bottom:1px solid #aaa;

-	color:black;

-	font-weight:normal;

-	margin:0;

-	padding:0;

-	padding-bottom:0.17em;

-	padding-top:0.5em;

-}

-h1 {

-	font-size:188%;

-	line-height:1.2em;

-	margin-bottom:0.1em;

-	padding-bottom:0;

-}

-h2 {

-	font-size:150%;

-}

-h3, h4, h5, h6 {

-	border-bottom:none;

-	font-weight:bold;

-}

-h3 {

-	font-size:132%;

-}

-h4 {

-	font-size:116%;

-}

-h5 {

-	font-size:100%;

-}

-h6 {

-	font-size:80%;

-}

-ul#page-actions, ul#page-actions-more {

-	float:right;

-	margin:10px 10px 0 10px;

-	padding:6px;

-	color:black;

-	background-color:#ececec;

-	list-style-type:none;

-	white-space: nowrap;

-	border-radius:5px;

-	-moz-border-radius:5px;

-}

-ul#user-actions {

-	padding:5px;

-	margin:0;

-	display:inline;

-	color:black;

-	background-color:#ececec;

-	list-style-type:none;

-	-moz-border-radius:3px;

-	border-radius:3px;

-}

-ul#page-actions li, ul#user-actions li, ul#page-actions-more li {

-	display:inline;

-}

-ul#page-actions a, ul#user-actions a, ul#page-actions-more a {

-	text-decoration:none;

-	color:black;

-	display:inline;

-	margin:0 3px;

-	padding:2px 0px 2px 18px;

-}

-ul#page-actions a:hover, ul#page-actions a:focus, ul#user-actions a:hover, ul#user-actions a:focus {

-	/*text-decoration:underline;*/

-}

-/***************************/

-ul#page-actions2 {

-	float:left;

-	margin:10px 10px 0 10px;

-	padding:6px;

-	color:black;

-	background-color:#ececec;

-	list-style-type:none;

-	border-radius:5px;

-	-moz-border-radius:5px;

-}

-ul#user-actions2 {

-	padding:5px;

-	margin:0;

-	display:inline;

-	color:black;

-	background-color:#ececec;

-	list-style-type:none;

-	border-radius:3px;

-	-moz-border-radius:3px;

-}

-ul#page-actions2 li, ul#user-actions2 li {

-	display:inline;

-}

-ul#page-actions2 a, ul#user-actions2 a {

-	text-decoration:none;

-	color:black;

-	display:inline;

-	margin:0 3px;

-	padding:2px 0px 2px 18px;

-}

-ul#page-actions2 a:hover, ul#page-actions2 a:focus, ul#user-actions2 a:hover, ul#user-actions2 a:focus,

-ul#page-actions-more a:hover, ul#page-actions-more a:focus{

-	color: #4e7bb4;

-}

-/****************************/

-.hidden {

-	display:none;

-}

-

-a.action.index {

-	background:transparent url(/media/default/img/wiki-tools-index.png) 0px 1px no-repeat;

-}

-a.action.recent {

-	background:transparent url(/media/default/img/wiki-tools-recent.png) 0px 1px no-repeat;

-}

-a.logout {

-	background:transparent url(/media/default/img/user-actions-logout.png) 0px 1px no-repeat;

-}

-

-a.info {

-    background:transparent url(/media/default/img/user-info.png) 0px 1px no-repeat;

-}

-

-a.admin {

-	background:transparent url(/media/default/img/user-actions-admin.png) 0px 1px no-repeat;

-}

-a.profile {

-	background:transparent url(/media/default/img/user-actions-profile.png) 0px 1px no-repeat;

-}

-a.create, a.edit {

-	background:transparent url(/media/default/img/page-tools-edit.png) 0px 1px no-repeat;

-}

-a.source, a.show {

-	background:transparent url(/media/default/img/page-tools-source.png) 0px 1px no-repeat;

-}

-a.revisions {

-	background:transparent url(/media/default/img/page-tools-revisions.png) 0px 1px no-repeat;

-}

-a.subscribe, a.unsubscribe {

-	background:transparent url(/media/default/img/page-tools-subscribe.png) 0px 1px no-repeat;

-}

-a.backlink {

-	background:transparent url(/media/default/img/page-tools-backlinks.png) 0px 1px no-repeat;

-}

-a.play {

-	background:transparent url(/media/default/img/control_play.png) 0px 1px no-repeat;

-}

-.time {

-	background:transparent url(/media/default/img/status_None.png) 0px 1px no-repeat;

-        padding: 2px 0px 2px 18px;

-        margin: 0px 3px;

-}

-.reconnect {

-	background:transparent url(/media/default/img/reconnect.png) 0px 1px no-repeat;

-        padding: 2px 0px 2px 18px;

-        margin: 0px 3px;

-}

-a.play:hover {

-	background:transparent url(/media/default/img/control_play_blue.png) 0px 1px no-repeat;

-}

-a.cancel {

-	background:transparent url(/media/default/img/control_cancel.png) 0px 1px no-repeat;

-}

-a.cancel:hover {

-	background:transparent url(/media/default/img/control_cancel_blue.png) 0px 1px no-repeat;

-}

-a.pause {

-	background:transparent url(/media/default/img/control_pause.png) 0px 1px no-repeat;

-}

-a.pause:hover {

-	background:transparent url(/media/default/img/control_pause_blue.png) 0px 1px no-repeat;

-	font-weight: bold;

-}

-a.stop {

-	background:transparent url(/media/default/img/control_stop.png) 0px 1px no-repeat;

-}

-a.stop:hover {

-	background:transparent url(/media/default/img/control_stop_blue.png) 0px 1px no-repeat;

-}

-a.add {

-	background:transparent url(/media/default/img/control_add.png) 0px 1px no-repeat;

-}

-a.add:hover {

-	background:transparent url(/media/default/img/control_add_blue.png) 0px 1px no-repeat;

-}

-a.cog {

-	background:transparent url(/media/default/img/cog.png) 0px 1px no-repeat;

-}

-#head-panel {

-	background:#525252 url(/media/default/img/head_bg1.png) bottom left repeat-x;

-}

-#head-panel h1 {

-	display:none;

-	margin:0;

-	text-decoration:none;

-	padding-top:0.8em;

-	padding-left:3.3em;

-	font-size:2.6em;

-	color:#eeeeec;

-}

-#head-panel #head-logo {

-	float:left;

-	margin:5px 0 -15px 5px;

-	padding:0;

-	overflow:visible;

-}

-#head-menu {

-	background:transparent url(/media/default/img/tabs-border-bottom.png) 0 100% repeat-x;

-	width:100%;

-	float:left;

-	margin:0;

-	padding:0;

-	padding-top:0.8em;

-}

-#head-menu ul {

-	list-style:none;

-	margin:0 1em 0 2em;

-}

-#head-menu ul li {

-	float:left;

-	margin:0;

-	margin-left:0.3em;

-	font-size:14px;

-	margin-bottom:4px;

-}

-#head-menu ul li.selected, #head-menu ul li:hover {

-	margin-bottom:0px;

-}

-#head-menu ul li a img {

-	height:22px;

-	width:22px;

-	vertical-align:middle;

-}

-#head-menu ul li a, #head-menu ul li a:link {

-	float:left;

-	text-decoration:none;

-	color:#555;

-	background:#eaeaea url(/media/default/img/tab-background.png) 0 100% repeat-x;

-	padding:3px 7px 3px 7px;

-	border:2px solid #ccc;

-	border-bottom:0px solid transparent;

-	padding-bottom:3px;

-	-moz-border-radius:5px;

-	border-radius:5px;

-}

-#head-menu ul li a:hover, #head-menu ul li a:focus {

-	color:#111;

-	padding-bottom:7px;

-	border-bottom:0px none transparent;

-	outline:none;

-	border-bottom-left-radius: 0px;

-	border-bottom-right-radius: 0px;

-	-moz-border-radius-bottomright:0px;

-	-moz-border-radius-bottomleft:0px;

-}

-#head-menu ul li a:focus {

-	margin-bottom:-4px;

-}

-#head-menu ul li.selected a {

-	color:#3566A5;

-	background:#fff;

-	padding-bottom:7px;

-	border-bottom:0px none transparent;

-	border-bottom-left-radius: 0px;

-	border-bottom-right-radius: 0px;

-	-moz-border-radius-bottomright:0px;

-	-moz-border-radius-bottomleft:0px;

-}

-#head-menu ul li.selected a:hover, #head-menu ul li.selected a:focus {

-	color:#111;

-}

-div#head-search-and-login {

-	float:right;

-	margin:0 1em 0 0;

-	background-color:#222;

-	padding:7px 7px 5px 5px;

-	color:white;

-	white-space: nowrap;

-	border-bottom-left-radius: 6px;

-	border-bottom-right-radius: 6px;

-	-moz-border-radius-bottomright:6px;

-	-moz-border-radius-bottomleft:6px;

-}

-div#head-search-and-login form {

-	display:inline;

-	padding:0 3px;

-}

-div#head-search-and-login form input {

-	border:2px solid #888;

-	background:#eee;

-	font-size:14px;

-	padding:2px;

-	border-radius:3px;

-	-moz-border-radius:3px;

-}

-div#head-search-and-login form input:focus {

-	background:#fff;

-}

-#head-search {

-	font-size:14px;

-}

-#head-username, #head-password {

-	width:80px;

-	font-size:14px;

-}

-#pageinfo {

-	clear:both;

-	color:#888;

-	padding:0.6em 0;

-	margin:0;

-}

-#foot {

-	font-style:normal;

-	color:#888;

-	text-align:center;

-}

-#foot a {

-	color:#aaf;

-}

-#foot img {

-	vertical-align:middle;

-}

-div.toc {

-	border:1px dotted #888;

-	background:#f0f0f0;

-	margin:1em 0 1em 1em;

-	float:right;

-	font-size:95%;

-}

-div.toc .tocheader {

-	font-weight:bold;

-	margin:0.5em 1em;

-}

-div.toc ol {

-	margin:1em 0.5em 1em 1em;

-	padding:0;

-}

-div.toc ol li {

-	margin:0;

-	padding:0;

-	margin-left:1em;

-}

-div.toc ol ol {

-	margin:0.5em 0.5em 0.5em 1em;

-	padding:0;

-}

-div.recentchanges table {

-	clear:both;

-}

-div#editor-help {

-	font-size:90%;

-	border:1px dotted #888;

-	padding:0ex 1ex 1ex 1ex;

-	background:#f7f6f2;

-}

-div#preview {

-	margin-top:1em;

-}

-label.block {

-	display:block;

-	text-align:right;

-	font-weight:bold;

-}

-label.simple {

-	display:block;

-	text-align:left;

-	font-weight:normal;

-}

-label.block input.edit {

-	width:50%;

-}

-/*fieldset {

-	width:300px;

-	text-align:center;

-	padding:0.5em;

-	margin:auto;

-}

-*/

-div.editor {

-	margin:0 0 0 0;

-}

-table {

-	margin:0.5em 0;

-	border-collapse:collapse;

-}

-td {

-	padding:0.25em;

-	border:1pt solid #ADB9CC;

-}

-td p {

-	margin:0;

-	padding:0;

-}

-.u {

-	text-decoration:underline;

-}

-.footnotes ul {

-	padding:0 2em;

-	margin:0 0 1em;

-}

-.footnotes li {

-	list-style:none;

-}

-.userpref table, .userpref td {

-	border:none;

-}

-#message {

-	clear:both;

-	padding:5px 10px;

-	background-color:#eee;

-	border-bottom:2px solid #ccc;

-}

-#message p {

-	margin:5px 0;

-	padding:0;

-	font-weight:bold;

-}

-#message div.buttons {

-	font-weight:normal;

-}

-.diff {

-	width:99%;

-}

-.diff-title {

-	background-color:#C0C0C0;

-}

-.searchresult dd span {

-	font-weight:bold;

-}

-.boxtext {

-	font-family:tahoma, arial, sans-serif;

-	font-size:11px;

-	color:#000;

-	float:none;

-	padding:3px 0 0 10px;

-}

-.statusbutton {

-	width:32px;

-	height:32px;

-	float:left;

-	margin-left:-32px;

-	margin-right:5px;

-	opacity:0;

-	cursor:pointer

-}

-.dlsize {

-	float:left;

-	padding-right: 8px;

-}

-.dlspeed {

-	float:left;

-	padding-right: 8px;

-}

-.package {

-	margin-bottom: 10px;

-}

-.packagename {

-	font-weight: bold;

-}

-

-.child {

-	margin-left: 20px;

-}

-.child_status {

-	margin-right: 10px;

-}

-.child_secrow {

-	font-size: 10px;

-}

-

-.header, .header th {

-	text-align: left;

-	font-weight: normal;

-	background-color:#ececec;

-	-moz-border-radius:5px;

-	border-radius:5px;

-}

-.progress_bar {

-	background: #0C0;

-	height: 5px;

-	

-}

-

-.queue {

-	border: none

-}

-

-.queue tr td {

-	border: none

-}

-

-.header, .header th{

-	text-align: left;

-	font-weight: normal;

-}

-

-

-.clearer

-{

-	clear: both;

-	height: 1px;

-}

-

-.left

-{

-	float: left;

-}

-

-.right

-{

-	float: right;

-}

-

-

-.setfield

-{

-    display: table-cell;

-}

-

-ul.tabs li a

-{

-   padding: 5px 16px 4px 15px;

-   border: none;

-   font-weight: bold;

-

-    border-radius: 5px 5px 0 0;

-    -moz-border-radius: 5px 5px 0 0;

-

-}

-

-

-#tabs span

-{

-    display: none;

-}

-

-#tabs span.selected

-{

-    display: inline;

-}

-

-#tabsback

-{

-    background-color: #525252;

-    margin: 2px 0 0;

-    padding: 6px 4px 1px 4px;

-

-    border-top-right-radius: 30px;

-    border-top-left-radius: 3px;

-    -moz-border-radius-topright: 30px;

-    -moz-border-radius-topleft: 3px;

-}

-ul.tabs

-{

-    list-style-type: none;

-    margin:0;

-    padding: 0 40px 0 0;

-}

-

-ul.tabs li

-{

-    display: inline;

-    margin-left: 8px;

-}

-

-

-ul.tabs li a

-{

-    color: #42454a;

-    background-color: #eaeaea;

-    border: 1px none #c9c3ba;

-    margin: 0;

-    text-decoration: none;

-

-    outline: 0;

-

-    padding: 5px 16px 4px 15px;

-    font-weight: bold;

-

-     border-radius: 5px 5px 0 0;

-     -moz-border-radius: 5px 5px 0 0;

-

-}

-

-ul.tabs li a.selected, ul.tabs li a:hover

-{

-    color: #000;

-    background-color: white;

-

-    border-bottom-right-radius: 0;

-    border-bottom-left-radius: 0;

-    -moz-border-radius-bottomright: 0;

-    -moz-border-radius-bottomleft: 0;

-}

-

-ul.tabs li a:hover

-{

-    background-color: #f1f4ee;

-}

-

-ul.tabs li a.selected

-{

-    font-weight: bold;

-    background-color: #525252;

-    padding-bottom: 5px;

-    color: white;

-}

-

-

-#tabs-body {

-    position: relative;

-    overflow: hidden;

-}

-

-

-span.tabContent

-{

-    border: 2px solid #525252;

-    margin: 0;

-    padding: 0;

-    padding-bottom: 10px;

-}

-

-#tabs-body > span {

-    display: none;

-}

-

-#tabs-body > span.active {

-    display: block;

-}

-

-.hide

-{

-    display: none;

-}

-

-.settable

-{

-    margin: 20px;

-    border: none;

-}

-.settable td

-{

-    border: none;

-    margin: 0;

-    padding: 5px;

-}

-

-.settable th{

-    padding-bottom: 8px;

-}

-

-.settable.wide td , .settable.wide th {

-    padding-left: 15px;

-    padding-right: 15px;

-}

-

-

-/*settings navbar*/

-ul.nav {

-    margin: -30px 0 0;

-    padding: 0;

-	list-style: none;

-    position: absolute;

-}

-

-

-ul.nav li {

-	position: relative;

-	float: left;

-	padding: 5px;

-}

-

-ul.nav > li a {

-    background: white;

-    -moz-border-radius: 4px 4px 4px 4px;

-    border: 1px solid #C9C3BA;

-    border-bottom: medium none;

-    color: black;

-}

-

-ul.nav ul {

-	position: absolute;

-	top: 26px;

-	left: 10px;

-	margin: 0;

-	padding: 0;

-	list-style: none;

-	border: 1px solid #AAA;

-	background: #f1f1f1;

-	-webkit-box-shadow: 1px 1px 5px #AAA;

-	-moz-box-shadow: 1px 1px 5px #AAA;

-	box-shadow: 1px 1px 5px #AAA;

-    cursor: pointer;

-}

-

-ul.nav .open {

-	display: block;

-}

-

-ul.nav .close {

-	display: none;

-}

-

-ul.nav ul li {

-	float: none;

-	padding: 0;

-}

-

-ul.nav ul li a {

-	width: 130px;

-	background: #f1f1f1;

-	padding: 3px;

-	display: block;

-	font-weight: normal;

-}

-

-ul.nav ul li a:hover {

-	background: #CDCDCD;

-}

-

-ul.nav ul ul {

-	left: 137px;

-	top: 0;

-}

-

-.purr-wrapper{

-	margin:10px;

-}

-

-/*Purr alert styles*/

-

-.purr-alert{

-	margin-bottom:10px;

-	padding:10px;

-	background:#000;

-	font-size:13px;

-	font-weight:bold;

-	color:#FFF;

-	-moz-border-radius:5px;

-	-webkit-border-radius:5px;

-	/*-moz-box-shadow: 0 0 10px rgba(255,255,0,.25);*/

-	width:300px;

-}

-.purr-alert.error{

-	color:#F55;

-	padding-left:30px;

-	background:url(/media/default/img/error.png) no-repeat #000 7px 10px;

-	width:280px;

-}

-.purr-alert.success{

-	color:#5F5;

-	padding-left:30px;

-	background:url(/media/default/img/success.png) no-repeat #000 7px 10px;

-	width:280px;

-}

-.purr-alert.notice{

-	color:#99F;

-	padding-left:30px;

-	background:url(/media/default/img//notice.png) no-repeat #000 7px 10px;

-	width:280px;

-}

-

-table.system {

-    border: none;

-    margin-left: 10px;

-}

-

-table.system td {

-    border: none

-}

-

-table.system tr > td:first-child {

-    font-weight: bold;

-    padding-right: 10px;

-}
\ No newline at end of file
diff --git a/module/web/media/default/css/log.css b/module/web/media/default/css/log.css
deleted file mode 100644
index 73786bfb4..000000000
--- a/module/web/media/default/css/log.css
+++ /dev/null
@@ -1,72 +0,0 @@
-
-html, body, #content
-{
-    height: 100%;
-}
-#body-wrapper
-{
-    height: 70%;
-}
-.logdiv
-{
-    height: 90%;
-    width: 100%;
-    overflow: auto;
-    border: 2px solid #CCC;
-    outline: 1px solid #666;
-    background-color: #FFE;
-    margin-right: auto;
-    margin-left: auto;
-}
-.logform
-{
-    display: table;
-    margin: 0 auto 0 auto;
-    padding-top: 5px;
-}
-.logtable
-{
-    
-    margin: 0px;
-}
-.logtable td
-{
-    border: none;
-    white-space: nowrap;
-
-    
-    font-family: monospace;
-    font-size: 16px;
-    margin: 0px;
-    padding: 0px 10px 0px 10px;
-    line-height: 110%;
-}
-td.logline
-{
-    background-color: #EEE;
-    text-align:right;
-    padding: 0px 5px 0px 5px;
-}
-td.loglevel
-{
-    text-align:right;
-}
-.logperpage
-{
-    float: right;
-    padding-bottom: 8px;
-}
-.logpaginator
-{
-    float: left;
-    padding-top: 5px;
-}
-.logpaginator a
-{
-    padding: 0px 8px 0px 8px;
-}
-.logwarn
-{
-    text-align: center;
-    color: red;
-}
\ No newline at end of file
diff --git a/module/web/media/default/css/pathchooser.css b/module/web/media/default/css/pathchooser.css
deleted file mode 100644
index 894cc335e..000000000
--- a/module/web/media/default/css/pathchooser.css
+++ /dev/null
@@ -1,68 +0,0 @@
-table {
-    width: 90%;
-    border: 1px dotted #888888;
-    font-family: sans-serif;
-    font-size: 10pt;
-}
-
-th {
-    background-color: #525252;
-    color: #E0E0E0;
-}
-
-table, tr, td {
-    background-color: #F0F0F0;
-}
-
-a, a:visited {
-    text-decoration: none;
-    font-weight: bold;
-}
-
-#paths {
-    width: 90%;
-    text-align: left;
-}
-
-.file_directory {
-    color: #c0c0c0;
-}
-.path_directory {
-    color: #3c3c3c;
-}
-.file_file {
-    color: #3c3c3c;
-}
-.path_file {
-    color: #c0c0c0;
-}
-
-.parentdir {
-    color: #000000;
-    font-size: 10pt;
-}
-.name {
-    text-align: left;
-}
-.size {
-    text-align: right;
-}
-.type {
-    text-align: left;
-}
-.mtime {
-    text-align: center;
-}
-
-.path_abs_rel {
-    color: #3c3c3c;
-    text-decoration: none;
-    font-weight: bold;
-    font-family: sans-serif;
-    font-size: 10pt;
-}
-
-.path_abs_rel a {
-    color: #3c3c3c;
-    font-style: italic;
-}
diff --git a/module/web/media/default/css/window.css b/module/web/media/default/css/window.css
deleted file mode 100644
index 8b13f55ec..000000000
--- a/module/web/media/default/css/window.css
+++ /dev/null
@@ -1,73 +0,0 @@
-/* ----------- stylized ----------- */

-.window_box h1{

-    font-size:14px;

-    font-weight:bold;

-    margin-bottom:8px;

-}

-.window_box p{

-    font-size:11px;

-    color:#666666;

-    margin-bottom:20px;

-    border-bottom:solid 1px #b7ddf2;

-    padding-bottom:10px;

-}

-.window_box label{

-    display:block;

-    font-weight:bold;

-    text-align:right;

-    width:240px;

-    float:left;

-}

-.window_box .small{

-    color:#666666;

-    display:block;

-    font-size:11px;

-    font-weight:normal;

-    text-align:right;

-    width:240px;

-}

-.window_box select, .window_box input{

-    float:left;

-    font-size:12px;

-    padding:4px 2px;

-    border:solid 1px #aacfe4;

-    width:300px;

-    margin:2px 0 20px 10px;

-}

-.window_box .cont{

-    float:left;

-    font-size:12px;

-    padding: 0px 10px 15px 0px;

-    width:300px;

-    margin:0px 0px 0px 10px;

-}

-.window_box .cont input{

-    float: none;

-    margin: 0px 15px 0px 1px;

-}

-.window_box textarea{

-    float:left;

-    font-size:12px;

-    padding:4px 2px;

-    border:solid 1px #aacfe4;

-    width:300px;

-    margin:2px 0 20px 10px;

-}

-.window_box button, .styled_button{

-    clear:both;

-    margin-left:150px;

-    width:125px;

-    height:31px;

-    background:#666666 url(../img/button.png) no-repeat;

-    text-align:center;

-    line-height:31px;

-    color:#FFFFFF;

-    font-size:11px;

-    font-weight:bold;

-    border: 0px;

-}

-

-.styled_button {

-    margin-left: 15px;

-    cursor: pointer;

-}

diff --git a/module/web/media/default/img/add_folder.png b/module/web/media/default/img/add_folder.png
deleted file mode 100644
index 8acbc411b..000000000
--- a/module/web/media/default/img/add_folder.png
+++ /dev/null
diff --git a/module/web/media/default/img/ajax-loader.gif b/module/web/media/default/img/ajax-loader.gif
deleted file mode 100644
index 2fd8e0737..000000000
--- a/module/web/media/default/img/ajax-loader.gif
+++ /dev/null
diff --git a/module/web/media/default/img/arrow_refresh.png b/module/web/media/default/img/arrow_refresh.png
deleted file mode 100644
index 0de26566d..000000000
--- a/module/web/media/default/img/arrow_refresh.png
+++ /dev/null
diff --git a/module/web/media/default/img/arrow_right.png b/module/web/media/default/img/arrow_right.png
deleted file mode 100644
index b1a181923..000000000
--- a/module/web/media/default/img/arrow_right.png
+++ /dev/null
diff --git a/module/web/media/default/img/big_button.gif b/module/web/media/default/img/big_button.gif
deleted file mode 100644
index 7680490ea..000000000
--- a/module/web/media/default/img/big_button.gif
+++ /dev/null
diff --git a/module/web/media/default/img/big_button_over.gif b/module/web/media/default/img/big_button_over.gif
deleted file mode 100644
index 2e3ee10d2..000000000
--- a/module/web/media/default/img/big_button_over.gif
+++ /dev/null
diff --git a/module/web/media/default/img/body.png b/module/web/media/default/img/body.png
deleted file mode 100644
index 7ff1043e0..000000000
--- a/module/web/media/default/img/body.png
+++ /dev/null
diff --git a/module/web/media/default/img/button.png b/module/web/media/default/img/button.png
deleted file mode 100644
index 890160614..000000000
--- a/module/web/media/default/img/button.png
+++ /dev/null
diff --git a/module/web/media/default/img/closebtn.gif b/module/web/media/default/img/closebtn.gif
deleted file mode 100644
index 3e27e6030..000000000
--- a/module/web/media/default/img/closebtn.gif
+++ /dev/null
diff --git a/module/web/media/default/img/cog.png b/module/web/media/default/img/cog.png
deleted file mode 100644
index 67de2c6cc..000000000
--- a/module/web/media/default/img/cog.png
+++ /dev/null
diff --git a/module/web/media/default/img/control_add.png b/module/web/media/default/img/control_add.png
deleted file mode 100644
index d39886893..000000000
--- a/module/web/media/default/img/control_add.png
+++ /dev/null
diff --git a/module/web/media/default/img/control_add_blue.png b/module/web/media/default/img/control_add_blue.png
deleted file mode 100644
index d11b7f41d..000000000
--- a/module/web/media/default/img/control_add_blue.png
+++ /dev/null
diff --git a/module/web/media/default/img/control_cancel.png b/module/web/media/default/img/control_cancel.png
deleted file mode 100644
index 7b9bc3fba..000000000
--- a/module/web/media/default/img/control_cancel.png
+++ /dev/null
diff --git a/module/web/media/default/img/control_cancel_blue.png b/module/web/media/default/img/control_cancel_blue.png
deleted file mode 100644
index 0c5c96ce3..000000000
--- a/module/web/media/default/img/control_cancel_blue.png
+++ /dev/null
diff --git a/module/web/media/default/img/control_pause.png b/module/web/media/default/img/control_pause.png
deleted file mode 100644
index 2d9ce9c4e..000000000
--- a/module/web/media/default/img/control_pause.png
+++ /dev/null
diff --git a/module/web/media/default/img/control_pause_blue.png b/module/web/media/default/img/control_pause_blue.png
deleted file mode 100644
index ec61099b0..000000000
--- a/module/web/media/default/img/control_pause_blue.png
+++ /dev/null
diff --git a/module/web/media/default/img/control_play.png b/module/web/media/default/img/control_play.png
deleted file mode 100644
index 0846555d0..000000000
--- a/module/web/media/default/img/control_play.png
+++ /dev/null
diff --git a/module/web/media/default/img/control_play_blue.png b/module/web/media/default/img/control_play_blue.png
deleted file mode 100644
index f8c8ec683..000000000
--- a/module/web/media/default/img/control_play_blue.png
+++ /dev/null
diff --git a/module/web/media/default/img/control_stop.png b/module/web/media/default/img/control_stop.png
deleted file mode 100644
index 893bb60e5..000000000
--- a/module/web/media/default/img/control_stop.png
+++ /dev/null
diff --git a/module/web/media/default/img/control_stop_blue.png b/module/web/media/default/img/control_stop_blue.png
deleted file mode 100644
index e6f75d232..000000000
--- a/module/web/media/default/img/control_stop_blue.png
+++ /dev/null
diff --git a/module/web/media/default/img/delete.png b/module/web/media/default/img/delete.png
deleted file mode 100644
index 08f249365..000000000
--- a/module/web/media/default/img/delete.png
+++ /dev/null
diff --git a/module/web/media/default/img/drag_corner.gif b/module/web/media/default/img/drag_corner.gif
deleted file mode 100644
index befb1adf1..000000000
--- a/module/web/media/default/img/drag_corner.gif
+++ /dev/null
diff --git a/module/web/media/default/img/error.png b/module/web/media/default/img/error.png
deleted file mode 100644
index c37bd062e..000000000
--- a/module/web/media/default/img/error.png
+++ /dev/null
diff --git a/module/web/media/default/img/folder.png b/module/web/media/default/img/folder.png
deleted file mode 100644
index 784e8fa48..000000000
--- a/module/web/media/default/img/folder.png
+++ /dev/null
diff --git a/module/web/media/default/img/full.png b/module/web/media/default/img/full.png
deleted file mode 100644
index fea52af76..000000000
--- a/module/web/media/default/img/full.png
+++ /dev/null
diff --git a/module/web/media/default/img/head-login.png b/module/web/media/default/img/head-login.png
deleted file mode 100644
index b59b7cbbf..000000000
--- a/module/web/media/default/img/head-login.png
+++ /dev/null
diff --git a/module/web/media/default/img/head-menu-collector.png b/module/web/media/default/img/head-menu-collector.png
deleted file mode 100644
index 861be40bc..000000000
--- a/module/web/media/default/img/head-menu-collector.png
+++ /dev/null
diff --git a/module/web/media/default/img/head-menu-config.png b/module/web/media/default/img/head-menu-config.png
deleted file mode 100644
index bbf43d4f3..000000000
--- a/module/web/media/default/img/head-menu-config.png
+++ /dev/null
diff --git a/module/web/media/default/img/head-menu-development.png b/module/web/media/default/img/head-menu-development.png
deleted file mode 100644
index fad150fe1..000000000
--- a/module/web/media/default/img/head-menu-development.png
+++ /dev/null
diff --git a/module/web/media/default/img/head-menu-download.png b/module/web/media/default/img/head-menu-download.png
deleted file mode 100644
index 98c5da9db..000000000
--- a/module/web/media/default/img/head-menu-download.png
+++ /dev/null
diff --git a/module/web/media/default/img/head-menu-home.png b/module/web/media/default/img/head-menu-home.png
deleted file mode 100644
index 9d62109aa..000000000
--- a/module/web/media/default/img/head-menu-home.png
+++ /dev/null
diff --git a/module/web/media/default/img/head-menu-index.png b/module/web/media/default/img/head-menu-index.png
deleted file mode 100644
index 44d631064..000000000
--- a/module/web/media/default/img/head-menu-index.png
+++ /dev/null
diff --git a/module/web/media/default/img/head-menu-news.png b/module/web/media/default/img/head-menu-news.png
deleted file mode 100644
index 43950ebc9..000000000
--- a/module/web/media/default/img/head-menu-news.png
+++ /dev/null
diff --git a/module/web/media/default/img/head-menu-queue.png b/module/web/media/default/img/head-menu-queue.png
deleted file mode 100644
index be98793ce..000000000
--- a/module/web/media/default/img/head-menu-queue.png
+++ /dev/null
diff --git a/module/web/media/default/img/head-menu-recent.png b/module/web/media/default/img/head-menu-recent.png
deleted file mode 100644
index fc9b0497f..000000000
--- a/module/web/media/default/img/head-menu-recent.png
+++ /dev/null
diff --git a/module/web/media/default/img/head-menu-wiki.png b/module/web/media/default/img/head-menu-wiki.png
deleted file mode 100644
index 07cf0102d..000000000
--- a/module/web/media/default/img/head-menu-wiki.png
+++ /dev/null
diff --git a/module/web/media/default/img/head-search-noshadow.png b/module/web/media/default/img/head-search-noshadow.png
deleted file mode 100644
index aafdae015..000000000
--- a/module/web/media/default/img/head-search-noshadow.png
+++ /dev/null
diff --git a/module/web/media/default/img/head_bg1.png b/module/web/media/default/img/head_bg1.png
deleted file mode 100644
index f2848c3cc..000000000
--- a/module/web/media/default/img/head_bg1.png
+++ /dev/null
diff --git a/module/web/media/default/img/images.png b/module/web/media/default/img/images.png
deleted file mode 100644
index 184860d1e..000000000
--- a/module/web/media/default/img/images.png
+++ /dev/null
diff --git a/module/web/media/default/img/notice.png b/module/web/media/default/img/notice.png
deleted file mode 100644
index 12cd1aef9..000000000
--- a/module/web/media/default/img/notice.png
+++ /dev/null
diff --git a/module/web/media/default/img/package_go.png b/module/web/media/default/img/package_go.png
deleted file mode 100644
index aace63ad6..000000000
--- a/module/web/media/default/img/package_go.png
+++ /dev/null
diff --git a/module/web/media/default/img/page-tools-backlinks.png b/module/web/media/default/img/page-tools-backlinks.png
deleted file mode 100644
index 3eb6a9ce3..000000000
--- a/module/web/media/default/img/page-tools-backlinks.png
+++ /dev/null
diff --git a/module/web/media/default/img/page-tools-edit.png b/module/web/media/default/img/page-tools-edit.png
deleted file mode 100644
index 188e1c12b..000000000
--- a/module/web/media/default/img/page-tools-edit.png
+++ /dev/null
diff --git a/module/web/media/default/img/page-tools-revisions.png b/module/web/media/default/img/page-tools-revisions.png
deleted file mode 100644
index 5c3b8587f..000000000
--- a/module/web/media/default/img/page-tools-revisions.png
+++ /dev/null
diff --git a/module/web/media/default/img/parseUri.png b/module/web/media/default/img/parseUri.png
deleted file mode 100644
index 937bded9d..000000000
--- a/module/web/media/default/img/parseUri.png
+++ /dev/null
diff --git a/module/web/media/default/img/pencil.png b/module/web/media/default/img/pencil.png
deleted file mode 100644
index 0bfecd50e..000000000
--- a/module/web/media/default/img/pencil.png
+++ /dev/null
diff --git a/module/web/media/default/img/pyload-logo-edited3.5-new-font-small.png b/module/web/media/default/img/pyload-logo-edited3.5-new-font-small.png
deleted file mode 100644
index 2443cd8b1..000000000
--- a/module/web/media/default/img/pyload-logo-edited3.5-new-font-small.png
+++ /dev/null
diff --git a/module/web/media/default/img/reconnect.png b/module/web/media/default/img/reconnect.png
deleted file mode 100644
index 49b269145..000000000
--- a/module/web/media/default/img/reconnect.png
+++ /dev/null
diff --git a/module/web/media/default/img/status_None.png b/module/web/media/default/img/status_None.png
deleted file mode 100644
index 293b13f77..000000000
--- a/module/web/media/default/img/status_None.png
+++ /dev/null
diff --git a/module/web/media/default/img/status_downloading.png b/module/web/media/default/img/status_downloading.png
deleted file mode 100644
index fb4ebc850..000000000
--- a/module/web/media/default/img/status_downloading.png
+++ /dev/null
diff --git a/module/web/media/default/img/status_failed.png b/module/web/media/default/img/status_failed.png
deleted file mode 100644
index c37bd062e..000000000
--- a/module/web/media/default/img/status_failed.png
+++ /dev/null
diff --git a/module/web/media/default/img/status_finished.png b/module/web/media/default/img/status_finished.png
deleted file mode 100644
index 89c8129a4..000000000
--- a/module/web/media/default/img/status_finished.png
+++ /dev/null
diff --git a/module/web/media/default/img/status_offline.png b/module/web/media/default/img/status_offline.png
deleted file mode 100644
index 0cfd58596..000000000
--- a/module/web/media/default/img/status_offline.png
+++ /dev/null
diff --git a/module/web/media/default/img/status_proc.png b/module/web/media/default/img/status_proc.png
deleted file mode 100644
index 67de2c6cc..000000000
--- a/module/web/media/default/img/status_proc.png
+++ /dev/null
diff --git a/module/web/media/default/img/status_queue.png b/module/web/media/default/img/status_queue.png
deleted file mode 100644
index 293b13f77..000000000
--- a/module/web/media/default/img/status_queue.png
+++ /dev/null
diff --git a/module/web/media/default/img/status_waiting.png b/module/web/media/default/img/status_waiting.png
deleted file mode 100644
index 2842cc338..000000000
--- a/module/web/media/default/img/status_waiting.png
+++ /dev/null
diff --git a/module/web/media/default/img/success.png b/module/web/media/default/img/success.png
deleted file mode 100644
index 89c8129a4..000000000
--- a/module/web/media/default/img/success.png
+++ /dev/null
diff --git a/module/web/media/default/img/tab-background.png b/module/web/media/default/img/tab-background.png
deleted file mode 100644
index 29a5d1991..000000000
--- a/module/web/media/default/img/tab-background.png
+++ /dev/null
diff --git a/module/web/media/default/img/tabs-border-bottom.png b/module/web/media/default/img/tabs-border-bottom.png
deleted file mode 100644
index 02440f428..000000000
--- a/module/web/media/default/img/tabs-border-bottom.png
+++ /dev/null
diff --git a/module/web/media/default/img/user-actions-logout.png b/module/web/media/default/img/user-actions-logout.png
deleted file mode 100644
index 0010931e2..000000000
--- a/module/web/media/default/img/user-actions-logout.png
+++ /dev/null
diff --git a/module/web/media/default/img/user-actions-profile.png b/module/web/media/default/img/user-actions-profile.png
deleted file mode 100644
index 46573fff6..000000000
--- a/module/web/media/default/img/user-actions-profile.png
+++ /dev/null
diff --git a/module/web/media/default/img/user-info.png b/module/web/media/default/img/user-info.png
deleted file mode 100644
index 6e643100f..000000000
--- a/module/web/media/default/img/user-info.png
+++ /dev/null
diff --git a/module/web/media/img/dialog-close.png b/module/web/media/img/dialog-close.png
deleted file mode 100644
index 81ebb88b2..000000000
--- a/module/web/media/img/dialog-close.png
+++ /dev/null
diff --git a/module/web/media/img/dialog-question.png b/module/web/media/img/dialog-question.png
deleted file mode 100644
index b0af3db5b..000000000
--- a/module/web/media/img/dialog-question.png
+++ /dev/null
diff --git a/module/web/media/img/favicon.ico b/module/web/media/img/favicon.ico
deleted file mode 100644
index 58b1f4b89..000000000
--- a/module/web/media/img/favicon.ico
+++ /dev/null
diff --git a/module/web/media/js/MooDialog_static.js b/module/web/media/js/MooDialog_static.js
deleted file mode 100644
index d497d3d57..000000000
--- a/module/web/media/js/MooDialog_static.js
+++ /dev/null
@@ -1,401 +0,0 @@
-/*
----
-
-name: Overlay
-
-authors:
-  - David Walsh (http://davidwalsh.name)
-
-license:
-  - MIT-style license
-
-requires: [Core/Class, Core/Element.Style, Core/Element.Event, Core/Element.Dimensions, Core/Fx.Tween]
-
-provides:
-  - Overlay
-...
-*/
-
-var Overlay = new Class({
-
-	Implements: [Options, Events],
-
-	options: {
-		id: 'overlay',
-		color: '#000',
-		duration: 500,
-		opacity: 0.5,
-		zIndex: 5000/*,
-		onClick: $empty,
-		onClose: $empty,
-		onHide: $empty,
-		onOpen: $empty,
-		onShow: $empty
-		*/
-	},
-
-	initialize: function(container, options){
-		this.setOptions(options);
-		this.container = document.id(container);
-
-		this.bound = {
-			'window': {
-				resize: this.resize.bind(this),
-				scroll: this.scroll.bind(this)
-			},
-			overlayClick: this.overlayClick.bind(this),
-			tweenStart: this.tweenStart.bind(this),
-			tweenComplete: this.tweenComplete.bind(this)
-		};
-
-		this.build().attach();
-	},
-
-	build: function(){
-	  this.overlay = new Element('div', {
-			id: this.options.id,
-			opacity: 0,
-			styles: {
-				position: (Browser.ie6) ? 'absolute' : 'fixed',
-				background: this.options.color,
-				left: 0,
-				top: 0,
-				'z-index': this.options.zIndex
-			}
-		}).inject(this.container);
-		this.tween = new Fx.Tween(this.overlay, {
-			duration: this.options.duration,
-			link: 'cancel',
-			property: 'opacity'
-		});
-        this.tween.set('opacity', 0)
-	 return this;
-	}.protect(),
-
-	attach: function(){
-		window.addEvents(this.bound.window);
-		this.overlay.addEvent('click', this.bound.overlayClick);
-		this.tween.addEvents({
-			onStart: this.bound.tweenStart,
-			onComplete: this.bound.tweenComplete
-		});
-	 return this;
-	},
-
-	detach: function(){
-		var args = Array.prototype.slice.call(arguments);
-		args.each(function(item){
-			if(item == 'window') window.removeEvents(this.bound.window);
-			if(item == 'overlay') this.overlay.removeEvent('click', this.bound.overlayClick);
-		}, this);
-		return this;
-	},
-
-	overlayClick: function(){
-		this.fireEvent('click');
-		return this;
-	},
-
-	tweenStart: function(){
-		this.overlay.setStyles({
-			width: '100%',
-			height: this.container.getScrollSize().y
-		});
-	 return this;
-	},
-
-	tweenComplete: function(){
-		this.fireEvent(this.overlay.get('opacity') == this.options.opacity ? 'show' : 'hide');
-		return this;
-	},
-
-	open: function(){
-		this.fireEvent('open');
-        this.tween.set('display', 'block');
-		this.tween.start(this.options.opacity);
-		return this;
-	},
-
-	close: function(){
-		this.fireEvent('close');
-		this.tween.start(0).chain(function(){
-            this.tween.set('display', 'none');
-        }.bind(this));
-		return this;
-	},
-
-	resize: function(){
-		this.fireEvent('resize');
-		this.overlay.setStyle('height', this.container.getScrollSize().y);
-		return this;
-	},
-
-	scroll: function(){
-		this.fireEvent('scroll');
-		if (Browser.ie6) this.overlay.setStyle('left', window.getScroll().x);
-		return this;
-	}
-
-});
-/*
----
-name: MooDialog
-description: The base class of MooDialog
-authors: Arian Stolwijk
-license:  MIT-style license
-requires: [Core/Class, Core/Element, Core/Element.Styles, Core/Element.Event]
-provides: [MooDialog, Element.MooDialog]
-...
-*/
-
-
-var MooDialog = new Class({
-
-	Implements: [Options, Events],
-
-	options: {
-		'class': 'MooDialog',
-		title: null,
-		scroll: true, // IE
-		forceScroll: false,
-		useEscKey: true,
-		destroyOnHide: true,
-		autoOpen: true,
-		closeButton: true,
-		onInitialize: function(){
-			this.wrapper.setStyle('display', 'none');
-		},
-		onBeforeOpen: function(){
-			this.wrapper.setStyle('display', 'block');
-			this.fireEvent('show');
-		},
-		onBeforeClose: function(){
-			this.wrapper.setStyle('display', 'none');
-			this.fireEvent('hide');
-		}/*,
-		onOpen: function(){},
-		onClose: function(){},
-		onShow: function(){},
-		onHide: function(){}*/
-	},
-
-	initialize: function(options){
-		this.setOptions(options);
-		this.options.inject = this.options.inject || document.body;
-		options = this.options;
-
-		var wrapper = this.wrapper = new Element('div.' + options['class'].replace(' ', '.')).inject(options.inject);
-		this.content = new Element('div.content').inject(wrapper);
-        wrapper.setStyle('display', 'none');
-
-		if (options.title){
-			this.title = new Element('div.title').set('text', options.title).inject(wrapper);
-			wrapper.addClass('MooDialogTitle');
-		}
-
-		if (options.closeButton){
-			this.closeButton = new Element('a.close', {
-				events: {click: this.close.bind(this)}
-			}).inject(wrapper);
-		}
-
-
-		/*<ie6>*/// IE 6 scroll
-		if ((options.scroll && Browser.ie6) || options.forceScroll){
-			wrapper.setStyle('position', 'absolute');
-			var position = wrapper.getPosition(options.inject);
-			window.addEvent('scroll', function(){
-				var scroll = document.getScroll();
-				wrapper.setPosition({
-					x: position.x + scroll.x,
-					y: position.y + scroll.y
-				});
-			});
-		}
-		/*</ie6>*/
-
-		if (options.useEscKey){
-			// Add event for the esc key
-			document.addEvent('keydown', function(e){
-				if (e.key == 'esc') this.close();
-			}.bind(this));
-		}
-
-		this.addEvent('hide', function(){
-			if (options.destroyOnHide) this.destroy();
-		}.bind(this));
-
-		this.fireEvent('initialize', wrapper);
-	},
-
-	setContent: function(){
-		var content = Array.from(arguments);
-		if (content.length == 1) content = content[0];
-
-		this.content.empty();
-
-		var type = typeOf(content);
-		if (['string', 'number'].contains(type)) this.content.set('text', content);
-		else this.content.adopt(content);
-
-		return this;
-	},
-
-	open: function(){
-		this.fireEvent('beforeOpen', this.wrapper).fireEvent('open');
-		this.opened = true;
-		return this;
-	},
-
-	close: function(){
-		this.fireEvent('beforeClose', this.wrapper).fireEvent('close');
-		this.opened = false;
-		return this;
-	},
-
-	destroy: function(){
-		this.wrapper.destroy();
-	},
-
-	toElement: function(){
-		return this.wrapper;
-	}
-
-});
-
-
-Element.implement({
-
-	MooDialog: function(options){
-		this.store('MooDialog',
-			new MooDialog(options).setContent(this).open()
-		);
-		return this;
-	}
-
-});
-/*
----
-name: MooDialog.Fx
-description: Overwrite the default events so the Dialogs are using Fx on open and close
-authors: Arian Stolwijk
-license: MIT-style license
-requires: [Cores/Fx.Tween, Overlay]
-provides: MooDialog.Fx
-...
-*/
-
-
-MooDialog.implement('options', {
-
-	duration: 400,
-	closeOnOverlayClick: true,
-
-	onInitialize: function(wrapper){
-		this.fx = new Fx.Tween(wrapper, {
-			property: 'opacity',
-			duration: this.options.duration
-		}).set(0);
-		this.overlay = new Overlay(this.options.inject, {
-			    duration: this.options.duration
-        });
-		if (this.options.closeOnOverlayClick) this.overlay.addEvent('click', this.close.bind(this));
-	},
-
-	onBeforeOpen: function(wrapper){
-		this.overlay.open();
-        wrapper.setStyle('display', 'block');
-		this.fx.start(1).chain(function(){
-			this.fireEvent('show');
-		}.bind(this));
-	},
-
-	onBeforeClose: function(wrapper){
-		this.overlay.close();
-		this.fx.start(0).chain(function(){
-			this.fireEvent('hide');
-            wrapper.setStyle('display', 'none');
-		}.bind(this));
-	}
-
-});
-/*
----
-name: MooDialog.Confirm
-description: Creates an Confirm Dialog
-authors: Arian Stolwijk
-license:  MIT-style license
-requires: MooDialog
-provides: [MooDialog.Confirm, Element.confirmLinkClick, Element.confirmFormSubmit]
-...
-*/
-
-
-MooDialog.Confirm = new Class({
-
-	Extends: MooDialog,
-
-	options: {
-		okText: 'Ok',
-		cancelText: 'Cancel',
-		focus: true,
-		textPClass: 'MooDialogConfirm'
-	},
-
-	initialize: function(msg, fn, fn1, options){
-		this.parent(options);
-		var emptyFn = function(){},
-			self = this;
-
-		var buttons = [
-			{fn: fn || emptyFn, txt: this.options.okText},
-			{fn: fn1 || emptyFn, txt: this.options.cancelText}
-		].map(function(button){
-			return new Element('input[type=button]', {
-				events: {
-					click: function(){
-						button.fn();
-						self.close();
-					}
-				},
-				value: button.txt
-			});
-		});
-
-		this.setContent(
-			new Element('p.' + this.options.textPClass, {text: msg}),
-			new Element('div.buttons').adopt(buttons)
-		);
-		if (this.options.autoOpen) this.open();
-
-		if(this.options.focus) this.addEvent('show', function(){
-			buttons[1].focus();
-		});
-
-	}
-});
-
-
-Element.implement({
-
-	confirmLinkClick: function(msg, options){
-		this.addEvent('click', function(e){
-			e.stop();
-			new MooDialog.Confirm(msg, function(){
-				location.href = this.get('href');
-			}.bind(this), null, options)
-		});
-		return this;
-	},
-
-	confirmFormSubmit: function(msg, options){
-		this.addEvent('submit', function(e){
-			e.stop();
-			new MooDialog.Confirm(msg, function(){
-				this.submit();
-			}.bind(this), null, options)
-		}.bind(this));
-		return this;
-	}
-
-});
diff --git a/module/web/media/js/MooDropMenu_static.js b/module/web/media/js/MooDropMenu_static.js
deleted file mode 100644
index b9cd8cc10..000000000
--- a/module/web/media/js/MooDropMenu_static.js
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
----
-description: This provides a simple Drop Down menu with infinit levels
-
-license: MIT-style
-
-authors:
-- Arian Stolwijk
-
-requires:
-  - Core/Class.Extras
-  - Core/Element.Event
-  - Core/Selectors
-
-provides: [MooDropMenu, Element.MooDropMenu]
-
-...
-*/
-
-var MooDropMenu = new Class({
-
-	Implements: [Options, Events],
-
-	options: {
-		onOpen: function(el){
-			el.removeClass('close').addClass('open');
-		},
-		onClose: function(el){
-			el.removeClass('open').addClass('close');
-		},
-		onInitialize: function(el){
-			el.removeClass('open').addClass('close');
-		},
-		mouseoutDelay: 200,
-		mouseoverDelay: 0,
-		listSelector: 'ul',
-		itemSelector: 'li'
-	},
-
-	initialize: function(menu, options, level){
-		this.setOptions(options);
-		options = this.options;
-
-		var menu = this.menu = document.id(menu);
-
-		menu.getElements(options.itemSelector + ' > ' + options.listSelector).each(function(el){
-
-			this.fireEvent('initialize', el);
-
-			var parent = el.getParent(options.itemSelector),
-				timer;
-
-			parent.addEvents({
-
-				'mouseenter': function(){
-					parent.store('DropDownOpen', true);
-
-					clearTimeout(timer);
-					if (options.mouseoverDelay) timer = this.fireEvent.delay(options.mouseoverDelay, this, ['open', el]);
-					else this.fireEvent('open', el);
-
-				}.bind(this),
-
-				'mouseleave': function(){
-					parent.store('DropDownOpen', false);
-
-					clearTimeout(timer);
-					timer = (function(){
-						if (!parent.retrieve('DropDownOpen')) this.fireEvent('close', el);
-					}).delay(options.mouseoutDelay, this);
-
-				}.bind(this)
-			});
-
-		}, this);
-	},
-
-	toElement: function(){
-		return this.menu
-	}
-
-});
-
-/* So you can do like this $('nav').MooDropMenu(); or even $('nav').MooDropMenu().setStyle('border',1); */
-Element.implement({
-	MooDropMenu: function(options){
-		return this.store('MooDropMenu', new MooDropMenu(this, options));
-	}
-});
diff --git a/module/web/media/js/admin.coffee b/module/web/media/js/admin.coffee
deleted file mode 100644
index 82b0dd3ec..000000000
--- a/module/web/media/js/admin.coffee
+++ /dev/null
@@ -1,58 +0,0 @@
-root = this
-
-window.addEvent "domready", ->
-
-    root.passwordDialog = new MooDialog {destroyOnHide: false}
-    root.passwordDialog.setContent $ 'password_box'
-
-    $("login_password_reset").addEvent "click", (e) -> root.passwordDialog.close()
-    $("login_password_button").addEvent "click", (e) ->
-
-        newpw = $("login_new_password").get("value")
-        newpw2 = $("login_new_password2").get("value")
-
-        if newpw is newpw2
-            form = $("password_form")
-            form.set "send", {
-                onSuccess: (data) ->
-                    root.notify.alert "Success", {
-                            'className': 'success'
-                        }
-                onFailure: (data) ->
-                    root.notify.alert "Error", {
-                            'className': 'error'
-                        }
-                }
-
-            form.send()
-
-            root.passwordDialog.close()
-        else
-            alert '{{_("Passwords did not match.")}}'
-
-        e.stop()
-
-    for item in $$(".change_password")
-        id = item.get("id")
-        user = id.split("|")[1]
-        $("user_login").set("value", user)
-        item.addEvent "click", (e) -> root.passwordDialog.open()
-
-    $('quit-pyload').addEvent "click", (e) ->
-        new MooDialog.Confirm "{{_('You are really sure you want to quit pyLoad?')}}", ->
-            new Request.JSON({
-                url: '/api/kill'
-                method: 'get'
-            }).send()
-        , ->
-        e.stop()
-
-    $('restart-pyload').addEvent "click", (e) ->
-        new MooDialog.Confirm "{{_('Are you sure you want to restart pyLoad?')}}", ->
-            new Request.JSON({
-                url: '/api/restart'
-                method: 'get'
-                onSuccess: (data) -> alert "{{_('pyLoad restarted')}}"
-            }).send()
-        , ->
-        e.stop()
\ No newline at end of file
diff --git a/module/web/media/js/admin.js b/module/web/media/js/admin.js
deleted file mode 100644
index d34d310a0..000000000
--- a/module/web/media/js/admin.js
+++ /dev/null
@@ -1,3 +0,0 @@
-{% autoescape true %}
-var root;root=this;window.addEvent("domready",function(){var f,c,b,e,a,d;root.passwordDialog=new MooDialog({destroyOnHide:false});root.passwordDialog.setContent($("password_box"));$("login_password_reset").addEvent("click",function(g){return root.passwordDialog.close()});$("login_password_button").addEvent("click",function(j){var h,i,g;i=$("login_new_password").get("value");g=$("login_new_password2").get("value");if(i===g){h=$("password_form");h.set("send",{onSuccess:function(k){return root.notify.alert("Success",{className:"success"})},onFailure:function(k){return root.notify.alert("Error",{className:"error"})}});h.send();root.passwordDialog.close()}else{alert('{{_("Passwords did not match.")}}')}return j.stop()});d=$$(".change_password");for(e=0,a=d.length;e<a;e++){c=d[e];f=c.get("id");b=f.split("|")[1];$("user_login").set("value",b);c.addEvent("click",function(g){return root.passwordDialog.open()})}$("quit-pyload").addEvent("click",function(g){new MooDialog.Confirm("{{_('You are really sure you want to quit pyLoad?')}}",function(){return new Request.JSON({url:"/api/kill",method:"get"}).send()},function(){});return g.stop()});return $("restart-pyload").addEvent("click",function(g){new MooDialog.Confirm("{{_('Are you sure you want to restart pyLoad?')}}",function(){return new Request.JSON({url:"/api/restart",method:"get",onSuccess:function(h){return alert("{{_('pyLoad restarted')}}")}}).send()},function(){});return g.stop()})});
-{% endautoescape %}
\ No newline at end of file
diff --git a/module/web/media/js/base.coffee b/module/web/media/js/base.coffee
deleted file mode 100644
index 3b5d33e82..000000000
--- a/module/web/media/js/base.coffee
+++ /dev/null
@@ -1,173 +0,0 @@
-# External scope
-root = this
-
-# helper functions
-humanFileSize = (size) ->
-    filesizename = new Array("B", "KiB", "MiB", "GiB", "TiB", "PiB")
-    loga = Math.log(size) / Math.log(1024)
-    i = Math.floor(loga)
-    a = Math.pow(1024, i)
-    if size is 0 then "0 B" else (Math.round(size * 100 / a) / 100 + " " + filesizename[i])
-
-parseUri = () ->
-    oldString = $("add_links").value
-    regxp = new RegExp('(ht|f)tp(s?):\/\/[a-zA-Z0-9\-\.\/\?=_&%#]+[<| |\"|\'|\r|\n|\t]{1}', 'g')
-    resu = oldString.match regxp
-    return if resu == null
-    res = "";
-
-    for part in resu
-        if part.indexOf(" ") != -1
-            res = res + part.replace(" ", " \n")
-        else if part.indexOf("\t") != -1
-            res = res + part.replace("\t", " \n")
-        else if part.indexOf("\r") != -1
-            res = res + part.replace("\r", " \n")
-        else if part.indexOf("\"") != -1
-            res = res + part.replace("\"", " \n")
-        else if part.indexOf("<") != -1
-            res = res + part.replace("<", " \n")
-        else if part.indexOf("'") != -1
-            res = res + part.replace("'", " \n")
-        else
-            res = res + part.replace("\n", " \n")
-
-    $("add_links").value = res;
-
-
-Array::remove = (from, to) ->
-    rest = this.slice((to || from) + 1 || this.length)
-    this.length = from < 0 ? this.length + from : from
-    return [] if this.length == 0
-    return this.push.apply(this, rest)
-
-
-document.addEvent "domready", ->
-
-    # global notification
-    root.notify = new Purr {
-        'mode': 'top'
-        'position': 'center'
-    }
-
-    root.captchaBox = new MooDialog {destroyOnHide: false}
-    root.captchaBox.setContent $ 'cap_box'
-
-    root.addBox = new MooDialog {destroyOnHide: false}
-    root.addBox.setContent $ 'add_box'
-
-    $('add_form').onsubmit = ->
-        $('add_form').target = 'upload_target'
-        if $('add_name').value is "" and $('add_file').value is ""
-            alert '{{_("Please Enter a packagename.")}}'
-            return false
-        else
-            root.addBox.close()
-            return true
-
-    $('add_reset').addEvent 'click', -> root.addBox.close()
-
-    $('action_add').addEvent 'click', -> $("add_form").reset(); root.addBox.open()
-    $('action_play').addEvent 'click', -> new Request({method: 'get', url: '/api/unpauseServer'}).send()
-    $('action_cancel').addEvent 'click', -> new Request({method: 'get', url: '/api/stopAllDownloads'}).send()
-    $('action_stop').addEvent 'click', -> new Request({method: 'get', url: '/api/pauseServer'}).send()
-
-
-    # captcha events
-
-    $('cap_info').addEvent 'click', ->
-        load_captcha "get", ""
-        root.captchaBox.open()
-    $('cap_reset').addEvent 'click', -> root.captchaBox.close()
-    $('cap_form').addEvent 'submit', (e) ->
-        submit_captcha()
-        e.stop()
-
-    $('cap_positional').addEvent 'click', on_captcha_click
-
-    new Request.JSON({
-        url: "/json/status"
-        onSuccess: LoadJsonToContent
-        secure: false
-        async: true
-        initialDelay: 0
-        delay: 4000
-        limit: 3000
-    }).startTimer()
-
-LoadJsonToContent = (data) ->
-    $("speed").set 'text', humanFileSize(data.speed)+"/s"
-    $("aktiv").set 'text', data.active
-    $("aktiv_from").set 'text', data.queue
-    $("aktiv_total").set 'text', data.total
-
-    if data.captcha
-        if $("cap_info").getStyle("display") != "inline"
-            $("cap_info").setStyle 'display', 'inline'
-            root.notify.alert '{{_("New Captcha Request")}}', {
-                            'className': 'notify'
-                        }
-    else
-        $("cap_info").setStyle 'display', 'none'
-
-
-    if data.download
-        $("time").set 'text', ' {{_("on")}}'
-        $("time").setStyle 'background-color', "#8ffc25"
-    else
-        $("time").set 'text', ' {{_("off")}}'
-        $("time").setStyle 'background-color', "#fc6e26"
-
-    if data.reconnect
-        $("reconnect").set 'text', ' {{_("on")}}'
-        $("reconnect").setStyle 'background-color', "#8ffc25"
-    else
-        $("reconnect").set 'text', ' {{_("off")}}'
-        $("reconnect").setStyle 'background-color', "#fc6e26"
-
-    return null
-
-
-set_captcha = (data) ->
-    $('cap_id').set 'value', data.id
-    if (data.result_type is 'textual')
-        $('cap_textual_img').set 'src', data.src
-        $('cap_title').set 'text', '{{_("Please read the text on the captcha.")}}'
-        $('cap_submit').setStyle 'display', 'inline'
-        $('cap_textual').setStyle 'display', 'block'
-        $('cap_positional').setStyle 'display', 'none'
-
-    else if (data.result_type == 'positional')
-        $('cap_positional_img').set('src', data.src)
-        $('cap_title').set('text', '{{_("Please click on the right captcha position.")}}')
-        $('cap_submit').setStyle('display', 'none')
-        $('cap_textual').setStyle('display', 'none')
-
-
-load_captcha = (method, post) ->
-    new Request.JSON({
-        url: "/json/set_captcha"
-        onSuccess: (data) -> set_captcha(data) if data.captcha else clear_captcha()
-        secure: false
-        async: true
-        method: method
-    }).send(post)
-
-clear_captcha = ->
-    $('cap_textual').setStyle 'display', 'none'
-    $('cap_textual_img').set 'src', ''
-    $('cap_positional').setStyle 'display', 'none'
-    $('cap_positional_img').set 'src', ''
-    $('cap_title').set 'text', '{{_("No Captchas to read.")}}'
-
-submit_captcha = ->
-    load_captcha("post", "cap_id=" + $('cap_id').get('value') + "&cap_result=" + $('cap_result').get('value') );
-    $('cap_result').set('value', '')
-    false
-
-on_captcha_click = (e) -> 
-    position = e.target.getPosition()
-    x = e.page.x - position.x
-    y = e.page.y - position.y
-    $('cap_result').value = x + "," + y
-    submit_captcha()
\ No newline at end of file
diff --git a/module/web/media/js/base.js b/module/web/media/js/base.js
deleted file mode 100644
index c68b1047a..000000000
--- a/module/web/media/js/base.js
+++ /dev/null
@@ -1,3 +0,0 @@
-{% autoescape true %}
-var LoadJsonToContent,clear_captcha,humanFileSize,load_captcha,on_captcha_click,parseUri,root,set_captcha,submit_captcha;root=this;humanFileSize=function(f){var c,d,e,b;d=new Array("B","KiB","MiB","GiB","TiB","PiB");b=Math.log(f)/Math.log(1024);e=Math.floor(b);c=Math.pow(1024,e);if(f===0){return"0 B"}else{return Math.round(f*100/c)/100+" "+d[e]}};parseUri=function(){var b,c,g,e,d,f,a;b=$("add_links").value;g=new RegExp("(ht|f)tp(s?)://[a-zA-Z0-9-./?=_&%#]+[<| |\"|'|\r|\n|\t]{1}","g");d=b.match(g);if(d===null){return}e="";for(f=0,a=d.length;f<a;f++){c=d[f];if(c.indexOf(" ")!==-1){e=e+c.replace(" "," \n")}else{if(c.indexOf("\t")!==-1){e=e+c.replace("\t"," \n")}else{if(c.indexOf("\r")!==-1){e=e+c.replace("\r"," \n")}else{if(c.indexOf('"')!==-1){e=e+c.replace('"'," \n")}else{if(c.indexOf("<")!==-1){e=e+c.replace("<"," \n")}else{if(c.indexOf("'")!==-1){e=e+c.replace("'"," \n")}else{e=e+c.replace("\n"," \n")}}}}}}}return $("add_links").value=e};Array.prototype.remove=function(d,c){var a,b;a=this.slice((c||d)+1||this.length);this.length=(b=d<0)!=null?b:this.length+{from:d};if(this.length===0){return[]}return this.push.apply(this,a)};document.addEvent("domready",function(){root.notify=new Purr({mode:"top",position:"center"});root.captchaBox=new MooDialog({destroyOnHide:false});root.captchaBox.setContent($("cap_box"));root.addBox=new MooDialog({destroyOnHide:false});root.addBox.setContent($("add_box"));$("add_form").onsubmit=function(){$("add_form").target="upload_target";if($("add_name").value===""&&$("add_file").value===""){alert('{{_("Please Enter a packagename.")}}');return false}else{root.addBox.close();return true}};$("add_reset").addEvent("click",function(){return root.addBox.close()});$("action_add").addEvent("click",function(){$("add_form").reset();return root.addBox.open()});$("action_play").addEvent("click",function(){return new Request({method:"get",url:"/api/unpauseServer"}).send()});$("action_cancel").addEvent("click",function(){return new Request({method:"get",url:"/api/stopAllDownloads"}).send()});$("action_stop").addEvent("click",function(){return new Request({method:"get",url:"/api/pauseServer"}).send()});$("cap_info").addEvent("click",function(){load_captcha("get","");return root.captchaBox.open()});$("cap_reset").addEvent("click",function(){return root.captchaBox.close()});$("cap_form").addEvent("submit",function(a){submit_captcha();return a.stop()});$("cap_positional").addEvent("click",on_captcha_click);return new Request.JSON({url:"/json/status",onSuccess:LoadJsonToContent,secure:false,async:true,initialDelay:0,delay:4000,limit:3000}).startTimer()});LoadJsonToContent=function(a){$("speed").set("text",humanFileSize(a.speed)+"/s");$("aktiv").set("text",a.active);$("aktiv_from").set("text",a.queue);$("aktiv_total").set("text",a.total);if(a.captcha){if($("cap_info").getStyle("display")!=="inline"){$("cap_info").setStyle("display","inline");root.notify.alert('{{_("New Captcha Request")}}',{className:"notify"})}}else{$("cap_info").setStyle("display","none")}if(a.download){$("time").set("text",' {{_("on")}}');$("time").setStyle("background-color","#8ffc25")}else{$("time").set("text",' {{_("off")}}');$("time").setStyle("background-color","#fc6e26")}if(a.reconnect){$("reconnect").set("text",' {{_("on")}}');$("reconnect").setStyle("background-color","#8ffc25")}else{$("reconnect").set("text",' {{_("off")}}');$("reconnect").setStyle("background-color","#fc6e26")}return null};set_captcha=function(a){$("cap_id").set("value",a.id);if(a.result_type==="textual"){$("cap_textual_img").set("src",a.src);$("cap_title").set("text",'{{_("Please read the text on the captcha.")}}');$("cap_submit").setStyle("display","inline");$("cap_textual").setStyle("display","block");return $("cap_positional").setStyle("display","none")}else{if(a.result_type==="positional"){$("cap_positional_img").set("src",a.src);$("cap_title").set("text",'{{_("Please click on the right captcha position.")}}');$("cap_submit").setStyle("display","none");return $("cap_textual").setStyle("display","none")}}};load_captcha=function(b,a){return new Request.JSON({url:"/json/set_captcha",onSuccess:function(c){return set_captcha(c)(c.captcha?void 0:clear_captcha())},secure:false,async:true,method:b}).send(a)};clear_captcha=function(){$("cap_textual").setStyle("display","none");$("cap_textual_img").set("src","");$("cap_positional").setStyle("display","none");$("cap_positional_img").set("src","");return $("cap_title").set("text",'{{_("No Captchas to read.")}}')};submit_captcha=function(){load_captcha("post","cap_id="+$("cap_id").get("value")+"&cap_result="+$("cap_result").get("value"));$("cap_result").set("value","");return false};on_captcha_click=function(c){var b,a,d;b=c.target.getPosition();a=c.page.x-b.x;d=c.page.y-b.y;$("cap_result").value=a+","+d;return submit_captcha()};
-{% endautoescape %}
\ No newline at end of file
diff --git a/module/web/media/js/mootools-core-1.4.1.js b/module/web/media/js/mootools-core-1.4.1.js
deleted file mode 100644
index 835b4bbe2..000000000
--- a/module/web/media/js/mootools-core-1.4.1.js
+++ /dev/null
@@ -1,476 +0,0 @@
-/*
----
-MooTools: the javascript framework
-
-web build:
- - http://mootools.net/core/76bf47062d6c1983d66ce47ad66aa0e0
-
-packager build:
- - packager build Core/Core Core/Array Core/String Core/Number Core/Function Core/Object Core/Event Core/Browser Core/Class Core/Class.Extras Core/Slick.Parser Core/Slick.Finder Core/Element Core/Element.Style Core/Element.Event Core/Element.Delegation Core/Element.Dimensions Core/Fx Core/Fx.CSS Core/Fx.Tween Core/Fx.Morph Core/Fx.Transitions Core/Request Core/Request.HTML Core/Request.JSON Core/Cookie Core/JSON Core/DOMReady Core/Swiff
-
-copyrights:
-  - [MooTools](http://mootools.net)
-
-licenses:
-  - [MIT License](http://mootools.net/license.txt)
-...
-*/
-(function(){this.MooTools={version:"1.4.1",build:"d1fb25710e3c5482a219ab9dc675a4e0ad2176b6"};var o=this.typeOf=function(i){if(i==null){return"null";}if(i.$family){return i.$family();
-}if(i.nodeName){if(i.nodeType==1){return"element";}if(i.nodeType==3){return(/\S/).test(i.nodeValue)?"textnode":"whitespace";}}else{if(typeof i.length=="number"){if(i.callee){return"arguments";
-}if("item" in i){return"collection";}}}return typeof i;};var j=this.instanceOf=function(t,i){if(t==null){return false;}var s=t.$constructor||t.constructor;
-while(s){if(s===i){return true;}s=s.parent;}return t instanceof i;};var f=this.Function;var p=true;for(var k in {toString:1}){p=null;}if(p){p=["hasOwnProperty","valueOf","isPrototypeOf","propertyIsEnumerable","toLocaleString","toString","constructor"];
-}f.prototype.overloadSetter=function(s){var i=this;return function(u,t){if(u==null){return this;}if(s||typeof u!="string"){for(var v in u){i.call(this,v,u[v]);
-}if(p){for(var w=p.length;w--;){v=p[w];if(u.hasOwnProperty(v)){i.call(this,v,u[v]);}}}}else{i.call(this,u,t);}return this;};};f.prototype.overloadGetter=function(s){var i=this;
-return function(u){var v,t;if(s||typeof u!="string"){v=u;}else{if(arguments.length>1){v=arguments;}}if(v){t={};for(var w=0;w<v.length;w++){t[v[w]]=i.call(this,v[w]);
-}}else{t=i.call(this,u);}return t;};};f.prototype.extend=function(i,s){this[i]=s;}.overloadSetter();f.prototype.implement=function(i,s){this.prototype[i]=s;
-}.overloadSetter();var n=Array.prototype.slice;f.from=function(i){return(o(i)=="function")?i:function(){return i;};};Array.from=function(i){if(i==null){return[];
-}return(a.isEnumerable(i)&&typeof i!="string")?(o(i)=="array")?i:n.call(i):[i];};Number.from=function(s){var i=parseFloat(s);return isFinite(i)?i:null;
-};String.from=function(i){return i+"";};f.implement({hide:function(){this.$hidden=true;return this;},protect:function(){this.$protected=true;return this;
-}});var a=this.Type=function(u,t){if(u){var s=u.toLowerCase();var i=function(v){return(o(v)==s);};a["is"+u]=i;if(t!=null){t.prototype.$family=(function(){return s;
-}).hide();}}if(t==null){return null;}t.extend(this);t.$constructor=a;t.prototype.$constructor=t;return t;};var e=Object.prototype.toString;a.isEnumerable=function(i){return(i!=null&&typeof i.length=="number"&&e.call(i)!="[object Function]");
-};var q={};var r=function(i){var s=o(i.prototype);return q[s]||(q[s]=[]);};var b=function(t,x){if(x&&x.$hidden){return;}var s=r(this);for(var u=0;u<s.length;
-u++){var w=s[u];if(o(w)=="type"){b.call(w,t,x);}else{w.call(this,t,x);}}var v=this.prototype[t];if(v==null||!v.$protected){this.prototype[t]=x;}if(this[t]==null&&o(x)=="function"){m.call(this,t,function(i){return x.apply(i,n.call(arguments,1));
-});}};var m=function(i,t){if(t&&t.$hidden){return;}var s=this[i];if(s==null||!s.$protected){this[i]=t;}};a.implement({implement:b.overloadSetter(),extend:m.overloadSetter(),alias:function(i,s){b.call(this,i,this.prototype[s]);
-}.overloadSetter(),mirror:function(i){r(this).push(i);return this;}});new a("Type",a);var d=function(s,w,u){var t=(w!=Object),A=w.prototype;if(t){w=new a(s,w);
-}for(var x=0,v=u.length;x<v;x++){var B=u[x],z=w[B],y=A[B];if(z){z.protect();}if(t&&y){delete A[B];A[B]=y.protect();}}if(t){w.implement(A);}return d;};d("String",String,["charAt","charCodeAt","concat","indexOf","lastIndexOf","match","quote","replace","search","slice","split","substr","substring","trim","toLowerCase","toUpperCase"])("Array",Array,["pop","push","reverse","shift","sort","splice","unshift","concat","join","slice","indexOf","lastIndexOf","filter","forEach","every","map","some","reduce","reduceRight"])("Number",Number,["toExponential","toFixed","toLocaleString","toPrecision"])("Function",f,["apply","call","bind"])("RegExp",RegExp,["exec","test"])("Object",Object,["create","defineProperty","defineProperties","keys","getPrototypeOf","getOwnPropertyDescriptor","getOwnPropertyNames","preventExtensions","isExtensible","seal","isSealed","freeze","isFrozen"])("Date",Date,["now"]);
-Object.extend=m.overloadSetter();Date.extend("now",function(){return +(new Date);});new a("Boolean",Boolean);Number.prototype.$family=function(){return isFinite(this)?"number":"null";
-}.hide();Number.extend("random",function(s,i){return Math.floor(Math.random()*(i-s+1)+s);});var g=Object.prototype.hasOwnProperty;Object.extend("forEach",function(i,t,u){for(var s in i){if(g.call(i,s)){t.call(u,i[s],s,i);
-}}});Object.each=Object.forEach;Array.implement({forEach:function(u,v){for(var t=0,s=this.length;t<s;t++){if(t in this){u.call(v,this[t],t,this);}}},each:function(i,s){Array.forEach(this,i,s);
-return this;}});var l=function(i){switch(o(i)){case"array":return i.clone();case"object":return Object.clone(i);default:return i;}};Array.implement("clone",function(){var s=this.length,t=new Array(s);
-while(s--){t[s]=l(this[s]);}return t;});var h=function(s,i,t){switch(o(t)){case"object":if(o(s[i])=="object"){Object.merge(s[i],t);}else{s[i]=Object.clone(t);
-}break;case"array":s[i]=t.clone();break;default:s[i]=t;}return s;};Object.extend({merge:function(z,u,t){if(o(u)=="string"){return h(z,u,t);}for(var y=1,s=arguments.length;
-y<s;y++){var w=arguments[y];for(var x in w){h(z,x,w[x]);}}return z;},clone:function(i){var t={};for(var s in i){t[s]=l(i[s]);}return t;},append:function(w){for(var v=1,t=arguments.length;
-v<t;v++){var s=arguments[v]||{};for(var u in s){w[u]=s[u];}}return w;}});["Object","WhiteSpace","TextNode","Collection","Arguments"].each(function(i){new a(i);
-});var c=Date.now();String.extend("uniqueID",function(){return(c++).toString(36);});})();Array.implement({every:function(c,d){for(var b=0,a=this.length>>>0;
-b<a;b++){if((b in this)&&!c.call(d,this[b],b,this)){return false;}}return true;},filter:function(d,e){var c=[];for(var b=0,a=this.length>>>0;b<a;b++){if((b in this)&&d.call(e,this[b],b,this)){c.push(this[b]);
-}}return c;},indexOf:function(c,d){var b=this.length>>>0;for(var a=(d<0)?Math.max(0,b+d):d||0;a<b;a++){if(this[a]===c){return a;}}return -1;},map:function(c,e){var d=this.length>>>0,b=Array(d);
-for(var a=0;a<d;a++){if(a in this){b[a]=c.call(e,this[a],a,this);}}return b;},some:function(c,d){for(var b=0,a=this.length>>>0;b<a;b++){if((b in this)&&c.call(d,this[b],b,this)){return true;
-}}return false;},clean:function(){return this.filter(function(a){return a!=null;});},invoke:function(a){var b=Array.slice(arguments,1);return this.map(function(c){return c[a].apply(c,b);
-});},associate:function(c){var d={},b=Math.min(this.length,c.length);for(var a=0;a<b;a++){d[c[a]]=this[a];}return d;},link:function(c){var a={};for(var e=0,b=this.length;
-e<b;e++){for(var d in c){if(c[d](this[e])){a[d]=this[e];delete c[d];break;}}}return a;},contains:function(a,b){return this.indexOf(a,b)!=-1;},append:function(a){this.push.apply(this,a);
-return this;},getLast:function(){return(this.length)?this[this.length-1]:null;},getRandom:function(){return(this.length)?this[Number.random(0,this.length-1)]:null;
-},include:function(a){if(!this.contains(a)){this.push(a);}return this;},combine:function(c){for(var b=0,a=c.length;b<a;b++){this.include(c[b]);}return this;
-},erase:function(b){for(var a=this.length;a--;){if(this[a]===b){this.splice(a,1);}}return this;},empty:function(){this.length=0;return this;},flatten:function(){var d=[];
-for(var b=0,a=this.length;b<a;b++){var c=typeOf(this[b]);if(c=="null"){continue;}d=d.concat((c=="array"||c=="collection"||c=="arguments"||instanceOf(this[b],Array))?Array.flatten(this[b]):this[b]);
-}return d;},pick:function(){for(var b=0,a=this.length;b<a;b++){if(this[b]!=null){return this[b];}}return null;},hexToRgb:function(b){if(this.length!=3){return null;
-}var a=this.map(function(c){if(c.length==1){c+=c;}return c.toInt(16);});return(b)?a:"rgb("+a+")";},rgbToHex:function(d){if(this.length<3){return null;}if(this.length==4&&this[3]==0&&!d){return"transparent";
-}var b=[];for(var a=0;a<3;a++){var c=(this[a]-0).toString(16);b.push((c.length==1)?"0"+c:c);}return(d)?b:"#"+b.join("");}});String.implement({test:function(a,b){return((typeOf(a)=="regexp")?a:new RegExp(""+a,b)).test(this);
-},contains:function(a,b){return(b)?(b+this+b).indexOf(b+a+b)>-1:String(this).indexOf(a)>-1;},trim:function(){return String(this).replace(/^\s+|\s+$/g,"");
-},clean:function(){return String(this).replace(/\s+/g," ").trim();},camelCase:function(){return String(this).replace(/-\D/g,function(a){return a.charAt(1).toUpperCase();
-});},hyphenate:function(){return String(this).replace(/[A-Z]/g,function(a){return("-"+a.charAt(0).toLowerCase());});},capitalize:function(){return String(this).replace(/\b[a-z]/g,function(a){return a.toUpperCase();
-});},escapeRegExp:function(){return String(this).replace(/([-.*+?^${}()|[\]\/\\])/g,"\\$1");},toInt:function(a){return parseInt(this,a||10);},toFloat:function(){return parseFloat(this);
-},hexToRgb:function(b){var a=String(this).match(/^#?(\w{1,2})(\w{1,2})(\w{1,2})$/);return(a)?a.slice(1).hexToRgb(b):null;},rgbToHex:function(b){var a=String(this).match(/\d{1,3}/g);
-return(a)?a.rgbToHex(b):null;},substitute:function(a,b){return String(this).replace(b||(/\\?\{([^{}]+)\}/g),function(d,c){if(d.charAt(0)=="\\"){return d.slice(1);
-}return(a[c]!=null)?a[c]:"";});}});Number.implement({limit:function(b,a){return Math.min(a,Math.max(b,this));},round:function(a){a=Math.pow(10,a||0).toFixed(a<0?-a:0);
-return Math.round(this*a)/a;},times:function(b,c){for(var a=0;a<this;a++){b.call(c,a,this);}},toFloat:function(){return parseFloat(this);},toInt:function(a){return parseInt(this,a||10);
-}});Number.alias("each","times");(function(b){var a={};b.each(function(c){if(!Number[c]){a[c]=function(){return Math[c].apply(null,[this].concat(Array.from(arguments)));
-};}});Number.implement(a);})(["abs","acos","asin","atan","atan2","ceil","cos","exp","floor","log","max","min","pow","sin","sqrt","tan"]);Function.extend({attempt:function(){for(var b=0,a=arguments.length;
-b<a;b++){try{return arguments[b]();}catch(c){}}return null;}});Function.implement({attempt:function(a,c){try{return this.apply(c,Array.from(a));}catch(b){}return null;
-},bind:function(e){var a=this,b=arguments.length>1?Array.slice(arguments,1):null,d=function(){};var c=function(){var g=e,h=arguments.length;if(this instanceof c){d.prototype=a.prototype;
-g=new d;}var f=(!b&&!h)?a.call(g):a.apply(g,b&&h?b.concat(Array.slice(arguments)):b||arguments);return g==e?f:g;};return c;},pass:function(b,c){var a=this;
-if(b!=null){b=Array.from(b);}return function(){return a.apply(c,b||arguments);};},delay:function(b,c,a){return setTimeout(this.pass((a==null?[]:a),c),b);
-},periodical:function(c,b,a){return setInterval(this.pass((a==null?[]:a),b),c);}});(function(){var a=Object.prototype.hasOwnProperty;Object.extend({subset:function(d,g){var f={};
-for(var e=0,b=g.length;e<b;e++){var c=g[e];if(c in d){f[c]=d[c];}}return f;},map:function(b,e,f){var d={};for(var c in b){if(a.call(b,c)){d[c]=e.call(f,b[c],c,b);
-}}return d;},filter:function(b,e,g){var d={};for(var c in b){var f=b[c];if(a.call(b,c)&&e.call(g,f,c,b)){d[c]=f;}}return d;},every:function(b,d,e){for(var c in b){if(a.call(b,c)&&!d.call(e,b[c],c)){return false;
-}}return true;},some:function(b,d,e){for(var c in b){if(a.call(b,c)&&d.call(e,b[c],c)){return true;}}return false;},keys:function(b){var d=[];for(var c in b){if(a.call(b,c)){d.push(c);
-}}return d;},values:function(c){var b=[];for(var d in c){if(a.call(c,d)){b.push(c[d]);}}return b;},getLength:function(b){return Object.keys(b).length;},keyOf:function(b,d){for(var c in b){if(a.call(b,c)&&b[c]===d){return c;
-}}return null;},contains:function(b,c){return Object.keyOf(b,c)!=null;},toQueryString:function(b,c){var d=[];Object.each(b,function(h,g){if(c){g=c+"["+g+"]";
-}var f;switch(typeOf(h)){case"object":f=Object.toQueryString(h,g);break;case"array":var e={};h.each(function(k,j){e[j]=k;});f=Object.toQueryString(e,g);
-break;default:f=g+"="+encodeURIComponent(h);}if(h!=null){d.push(f);}});return d.join("&");}});})();(function(){var k=this.document;var i=k.window=this;
-var b=1;this.$uid=(i.ActiveXObject)?function(e){return(e.uid||(e.uid=[b++]))[0];}:function(e){return e.uid||(e.uid=b++);};$uid(i);$uid(k);var a=navigator.userAgent.toLowerCase(),c=navigator.platform.toLowerCase(),j=a.match(/(opera|ie|firefox|chrome|version)[\s\/:]([\w\d\.]+)?.*?(safari|version[\s\/:]([\w\d\.]+)|$)/)||[null,"unknown",0],f=j[1]=="ie"&&k.documentMode;
-var o=this.Browser={extend:Function.prototype.extend,name:(j[1]=="version")?j[3]:j[1],version:f||parseFloat((j[1]=="opera"&&j[4])?j[4]:j[2]),Platform:{name:a.match(/ip(?:ad|od|hone)/)?"ios":(a.match(/(?:webos|android)/)||c.match(/mac|win|linux/)||["other"])[0]},Features:{xpath:!!(k.evaluate),air:!!(i.runtime),query:!!(k.querySelector),json:!!(i.JSON)},Plugins:{}};
-o[o.name]=true;o[o.name+parseInt(o.version,10)]=true;o.Platform[o.Platform.name]=true;o.Request=(function(){var q=function(){return new XMLHttpRequest();
-};var p=function(){return new ActiveXObject("MSXML2.XMLHTTP");};var e=function(){return new ActiveXObject("Microsoft.XMLHTTP");};return Function.attempt(function(){q();
-return q;},function(){p();return p;},function(){e();return e;});})();o.Features.xhr=!!(o.Request);var h=(Function.attempt(function(){return navigator.plugins["Shockwave Flash"].description;
-},function(){return new ActiveXObject("ShockwaveFlash.ShockwaveFlash").GetVariable("$version");})||"0 r0").match(/\d+/g);o.Plugins.Flash={version:Number(h[0]||"0."+h[1])||0,build:Number(h[2])||0};
-o.exec=function(p){if(!p){return p;}if(i.execScript){i.execScript(p);}else{var e=k.createElement("script");e.setAttribute("type","text/javascript");e.text=p;
-k.head.appendChild(e);k.head.removeChild(e);}return p;};String.implement("stripScripts",function(p){var e="";var q=this.replace(/<script[^>]*>([\s\S]*?)<\/script>/gi,function(r,s){e+=s+"\n";
-return"";});if(p===true){o.exec(e);}else{if(typeOf(p)=="function"){p(e,q);}}return q;});o.extend({Document:this.Document,Window:this.Window,Element:this.Element,Event:this.Event});
-this.Window=this.$constructor=new Type("Window",function(){});this.$family=Function.from("window").hide();Window.mirror(function(e,p){i[e]=p;});this.Document=k.$constructor=new Type("Document",function(){});
-k.$family=Function.from("document").hide();Document.mirror(function(e,p){k[e]=p;});k.html=k.documentElement;if(!k.head){k.head=k.getElementsByTagName("head")[0];
-}if(k.execCommand){try{k.execCommand("BackgroundImageCache",false,true);}catch(g){}}if(this.attachEvent&&!this.addEventListener){var d=function(){this.detachEvent("onunload",d);
-k.head=k.html=k.window=null;};this.attachEvent("onunload",d);}var m=Array.from;try{m(k.html.childNodes);}catch(g){Array.from=function(p){if(typeof p!="string"&&Type.isEnumerable(p)&&typeOf(p)!="array"){var e=p.length,q=new Array(e);
-while(e--){q[e]=p[e];}return q;}return m(p);};var l=Array.prototype,n=l.slice;["pop","push","reverse","shift","sort","splice","unshift","concat","join","slice"].each(function(e){var p=l[e];
-Array[e]=function(q){return p.apply(Array.from(q),n.call(arguments,1));};});}})();(function(){var b={};var a=this.DOMEvent=new Type("DOMEvent",function(c,g){if(!g){g=window;
-}c=c||g.event;if(c.$extended){return c;}this.event=c;this.$extended=true;this.shift=c.shiftKey;this.control=c.ctrlKey;this.alt=c.altKey;this.meta=c.metaKey;
-var i=this.type=c.type;var h=c.target||c.srcElement;while(h&&h.nodeType==3){h=h.parentNode;}this.target=document.id(h);if(i.indexOf("key")==0){var d=this.code=(c.which||c.keyCode);
-this.key=b[d];if(i=="keydown"){if(d>111&&d<124){this.key="f"+(d-111);}else{if(d>95&&d<106){this.key=d-96;}}}if(this.key==null){this.key=String.fromCharCode(d).toLowerCase();
-}}else{if(i=="click"||i=="dblclick"||i=="contextmenu"||i=="DOMMouseScroll"||i.indexOf("mouse")==0){var j=g.document;j=(!j.compatMode||j.compatMode=="CSS1Compat")?j.html:j.body;
-this.page={x:(c.pageX!=null)?c.pageX:c.clientX+j.scrollLeft,y:(c.pageY!=null)?c.pageY:c.clientY+j.scrollTop};this.client={x:(c.pageX!=null)?c.pageX-g.pageXOffset:c.clientX,y:(c.pageY!=null)?c.pageY-g.pageYOffset:c.clientY};
-if(i=="DOMMouseScroll"||i=="mousewheel"){this.wheel=(c.wheelDelta)?c.wheelDelta/120:-(c.detail||0)/3;}this.rightClick=(c.which==3||c.button==2);if(i=="mouseover"||i=="mouseout"){var k=c.relatedTarget||c[(i=="mouseover"?"from":"to")+"Element"];
-while(k&&k.nodeType==3){k=k.parentNode;}this.relatedTarget=document.id(k);}}else{if(i.indexOf("touch")==0||i.indexOf("gesture")==0){this.rotation=c.rotation;
-this.scale=c.scale;this.targetTouches=c.targetTouches;this.changedTouches=c.changedTouches;var f=this.touches=c.touches;if(f&&f[0]){var e=f[0];this.page={x:e.pageX,y:e.pageY};
-this.client={x:e.clientX,y:e.clientY};}}}}if(!this.client){this.client={};}if(!this.page){this.page={};}});a.implement({stop:function(){return this.preventDefault().stopPropagation();
-},stopPropagation:function(){if(this.event.stopPropagation){this.event.stopPropagation();}else{this.event.cancelBubble=true;}return this;},preventDefault:function(){if(this.event.preventDefault){this.event.preventDefault();
-}else{this.event.returnValue=false;}return this;}});a.defineKey=function(d,c){b[d]=c;return this;};a.defineKeys=a.defineKey.overloadSetter(true);a.defineKeys({"38":"up","40":"down","37":"left","39":"right","27":"esc","32":"space","8":"backspace","9":"tab","46":"delete","13":"enter"});
-})();(function(){var a=this.Class=new Type("Class",function(h){if(instanceOf(h,Function)){h={initialize:h};}var g=function(){e(this);if(g.$prototyping){return this;
-}this.$caller=null;var i=(this.initialize)?this.initialize.apply(this,arguments):this;this.$caller=this.caller=null;return i;}.extend(this).implement(h);
-g.$constructor=a;g.prototype.$constructor=g;g.prototype.parent=c;return g;});var c=function(){if(!this.$caller){throw new Error('The method "parent" cannot be called.');
-}var g=this.$caller.$name,h=this.$caller.$owner.parent,i=(h)?h.prototype[g]:null;if(!i){throw new Error('The method "'+g+'" has no parent.');}return i.apply(this,arguments);
-};var e=function(g){for(var h in g){var j=g[h];switch(typeOf(j)){case"object":var i=function(){};i.prototype=j;g[h]=e(new i);break;case"array":g[h]=j.clone();
-break;}}return g;};var b=function(g,h,j){if(j.$origin){j=j.$origin;}var i=function(){if(j.$protected&&this.$caller==null){throw new Error('The method "'+h+'" cannot be called.');
-}var l=this.caller,m=this.$caller;this.caller=m;this.$caller=i;var k=j.apply(this,arguments);this.$caller=m;this.caller=l;return k;}.extend({$owner:g,$origin:j,$name:h});
-return i;};var f=function(h,i,g){if(a.Mutators.hasOwnProperty(h)){i=a.Mutators[h].call(this,i);if(i==null){return this;}}if(typeOf(i)=="function"){if(i.$hidden){return this;
-}this.prototype[h]=(g)?i:b(this,h,i);}else{Object.merge(this.prototype,h,i);}return this;};var d=function(g){g.$prototyping=true;var h=new g;delete g.$prototyping;
-return h;};a.implement("implement",f.overloadSetter());a.Mutators={Extends:function(g){this.parent=g;this.prototype=d(g);},Implements:function(g){Array.from(g).each(function(j){var h=new j;
-for(var i in h){f.call(this,i,h[i],true);}},this);}};})();(function(){this.Chain=new Class({$chain:[],chain:function(){this.$chain.append(Array.flatten(arguments));
-return this;},callChain:function(){return(this.$chain.length)?this.$chain.shift().apply(this,arguments):false;},clearChain:function(){this.$chain.empty();
-return this;}});var a=function(b){return b.replace(/^on([A-Z])/,function(c,d){return d.toLowerCase();});};this.Events=new Class({$events:{},addEvent:function(d,c,b){d=a(d);
-this.$events[d]=(this.$events[d]||[]).include(c);if(b){c.internal=true;}return this;},addEvents:function(b){for(var c in b){this.addEvent(c,b[c]);}return this;
-},fireEvent:function(e,c,b){e=a(e);var d=this.$events[e];if(!d){return this;}c=Array.from(c);d.each(function(f){if(b){f.delay(b,this,c);}else{f.apply(this,c);
-}},this);return this;},removeEvent:function(e,d){e=a(e);var c=this.$events[e];if(c&&!d.internal){var b=c.indexOf(d);if(b!=-1){delete c[b];}}return this;
-},removeEvents:function(d){var e;if(typeOf(d)=="object"){for(e in d){this.removeEvent(e,d[e]);}return this;}if(d){d=a(d);}for(e in this.$events){if(d&&d!=e){continue;
-}var c=this.$events[e];for(var b=c.length;b--;){if(b in c){this.removeEvent(e,c[b]);}}}return this;}});this.Options=new Class({setOptions:function(){var b=this.options=Object.merge.apply(null,[{},this.options].append(arguments));
-if(this.addEvent){for(var c in b){if(typeOf(b[c])!="function"||!(/^on[A-Z]/).test(c)){continue;}this.addEvent(c,b[c]);delete b[c];}}return this;}});})();
-(function(){var k,n,l,g,a={},c={},m=/\\/g;var e=function(q,p){if(q==null){return null;}if(q.Slick===true){return q;}q=(""+q).replace(/^\s+|\s+$/g,"");g=!!p;
-var o=(g)?c:a;if(o[q]){return o[q];}k={Slick:true,expressions:[],raw:q,reverse:function(){return e(this.raw,true);}};n=-1;while(q!=(q=q.replace(j,b))){}k.length=k.expressions.length;
-return o[k.raw]=(g)?h(k):k;};var i=function(o){if(o==="!"){return" ";}else{if(o===" "){return"!";}else{if((/^!/).test(o)){return o.replace(/^!/,"");}else{return"!"+o;
-}}}};var h=function(u){var r=u.expressions;for(var p=0;p<r.length;p++){var t=r[p];var q={parts:[],tag:"*",combinator:i(t[0].combinator)};for(var o=0;o<t.length;
-o++){var s=t[o];if(!s.reverseCombinator){s.reverseCombinator=" ";}s.combinator=s.reverseCombinator;delete s.reverseCombinator;}t.reverse().push(q);}return u;
-};var f=function(o){return o.replace(/[-[\]{}()*+?.\\^$|,#\s]/g,function(p){return"\\"+p;});};var j=new RegExp("^(?:\\s*(,)\\s*|\\s*(<combinator>+)\\s*|(\\s+)|(<unicode>+|\\*)|\\#(<unicode>+)|\\.(<unicode>+)|\\[\\s*(<unicode1>+)(?:\\s*([*^$!~|]?=)(?:\\s*(?:([\"']?)(.*?)\\9)))?\\s*\\](?!\\])|(:+)(<unicode>+)(?:\\((?:(?:([\"'])([^\\13]*)\\13)|((?:\\([^)]+\\)|[^()]*)+))\\))?)".replace(/<combinator>/,"["+f(">+~`!@$%^&={}\\;</")+"]").replace(/<unicode>/g,"(?:[\\w\\u00a1-\\uFFFF-]|\\\\[^\\s0-9a-f])").replace(/<unicode1>/g,"(?:[:\\w\\u00a1-\\uFFFF-]|\\\\[^\\s0-9a-f])"));
-function b(x,s,D,z,r,C,q,B,A,y,u,F,G,v,p,w){if(s||n===-1){k.expressions[++n]=[];l=-1;if(s){return"";}}if(D||z||l===-1){D=D||" ";var t=k.expressions[n];
-if(g&&t[l]){t[l].reverseCombinator=i(D);}t[++l]={combinator:D,tag:"*"};}var o=k.expressions[n][l];if(r){o.tag=r.replace(m,"");}else{if(C){o.id=C.replace(m,"");
-}else{if(q){q=q.replace(m,"");if(!o.classList){o.classList=[];}if(!o.classes){o.classes=[];}o.classList.push(q);o.classes.push({value:q,regexp:new RegExp("(^|\\s)"+f(q)+"(\\s|$)")});
-}else{if(G){w=w||p;w=w?w.replace(m,""):null;if(!o.pseudos){o.pseudos=[];}o.pseudos.push({key:G.replace(m,""),value:w,type:F.length==1?"class":"element"});
-}else{if(B){B=B.replace(m,"");u=(u||"").replace(m,"");var E,H;switch(A){case"^=":H=new RegExp("^"+f(u));break;case"$=":H=new RegExp(f(u)+"$");break;case"~=":H=new RegExp("(^|\\s)"+f(u)+"(\\s|$)");
-break;case"|=":H=new RegExp("^"+f(u)+"(-|$)");break;case"=":E=function(I){return u==I;};break;case"*=":E=function(I){return I&&I.indexOf(u)>-1;};break;
-case"!=":E=function(I){return u!=I;};break;default:E=function(I){return !!I;};}if(u==""&&(/^[*$^]=$/).test(A)){E=function(){return false;};}if(!E){E=function(I){return I&&H.test(I);
-};}if(!o.attributes){o.attributes=[];}o.attributes.push({key:B,operator:A,value:u,test:E});}}}}}return"";}var d=(this.Slick||{});d.parse=function(o){return e(o);
-};d.escapeRegExp=f;if(!this.Slick){this.Slick=d;}}).apply((typeof exports!="undefined")?exports:this);(function(){var k={},m={},d=Object.prototype.toString;
-k.isNativeCode=function(c){return(/\{\s*\[native code\]\s*\}/).test(""+c);};k.isXML=function(c){return(!!c.xmlVersion)||(!!c.xml)||(d.call(c)=="[object XMLDocument]")||(c.nodeType==9&&c.documentElement.nodeName!="HTML");
-};k.setDocument=function(x){var u=x.nodeType;if(u==9){}else{if(u){x=x.ownerDocument;}else{if(x.navigator){x=x.document;}else{return;}}}if(this.document===x){return;
-}this.document=x;var z=x.documentElement,v=this.getUIDXML(z),p=m[v],B;if(p){for(B in p){this[B]=p[B];}return;}p=m[v]={};p.root=z;p.isXMLDocument=this.isXML(x);
-p.brokenStarGEBTN=p.starSelectsClosedQSA=p.idGetsName=p.brokenMixedCaseQSA=p.brokenGEBCN=p.brokenCheckedQSA=p.brokenEmptyAttributeQSA=p.isHTMLDocument=p.nativeMatchesSelector=false;
-var n,o,y,r,s;var t,c="slick_uniqueid";var A=x.createElement("div");var q=x.body||x.getElementsByTagName("body")[0]||z;q.appendChild(A);try{A.innerHTML='<a id="'+c+'"></a>';
-p.isHTMLDocument=!!x.getElementById(c);}catch(w){}if(p.isHTMLDocument){A.style.display="none";A.appendChild(x.createComment(""));o=(A.getElementsByTagName("*").length>1);
-try{A.innerHTML="foo</foo>";t=A.getElementsByTagName("*");n=(t&&!!t.length&&t[0].nodeName.charAt(0)=="/");}catch(w){}p.brokenStarGEBTN=o||n;try{A.innerHTML='<a name="'+c+'"></a><b id="'+c+'"></b>';
-p.idGetsName=x.getElementById(c)===A.firstChild;}catch(w){}if(A.getElementsByClassName){try{A.innerHTML='<a class="f"></a><a class="b"></a>';A.getElementsByClassName("b").length;
-A.firstChild.className="b";r=(A.getElementsByClassName("b").length!=2);}catch(w){}try{A.innerHTML='<a class="a"></a><a class="f b a"></a>';y=(A.getElementsByClassName("a").length!=2);
-}catch(w){}p.brokenGEBCN=r||y;}if(A.querySelectorAll){try{A.innerHTML="foo</foo>";t=A.querySelectorAll("*");p.starSelectsClosedQSA=(t&&!!t.length&&t[0].nodeName.charAt(0)=="/");
-}catch(w){}try{A.innerHTML='<a class="MiX"></a>';p.brokenMixedCaseQSA=!A.querySelectorAll(".MiX").length;}catch(w){}try{A.innerHTML='<select><option selected="selected">a</option></select>';
-p.brokenCheckedQSA=(A.querySelectorAll(":checked").length==0);}catch(w){}try{A.innerHTML='<a class=""></a>';p.brokenEmptyAttributeQSA=(A.querySelectorAll('[class*=""]').length!=0);
-}catch(w){}}try{A.innerHTML='<form action="s"><input id="action"/></form>';s=(A.firstChild.getAttribute("action")!="s");}catch(w){}p.nativeMatchesSelector=z.matchesSelector||z.mozMatchesSelector||z.webkitMatchesSelector;
-if(p.nativeMatchesSelector){try{p.nativeMatchesSelector.call(z,":slick");p.nativeMatchesSelector=null;}catch(w){}}}try{z.slick_expando=1;delete z.slick_expando;
-p.getUID=this.getUIDHTML;}catch(w){p.getUID=this.getUIDXML;}q.removeChild(A);A=t=q=null;p.getAttribute=(p.isHTMLDocument&&s)?function(E,C){var F=this.attributeGetters[C];
-if(F){return F.call(E);}var D=E.getAttributeNode(C);return(D)?D.nodeValue:null;}:function(D,C){var E=this.attributeGetters[C];return(E)?E.call(D):D.getAttribute(C);
-};p.hasAttribute=(z&&this.isNativeCode(z.hasAttribute))?function(D,C){return D.hasAttribute(C);}:function(D,C){D=D.getAttributeNode(C);return !!(D&&(D.specified||D.nodeValue));
-};p.contains=(z&&this.isNativeCode(z.contains))?function(C,D){return C.contains(D);}:(z&&z.compareDocumentPosition)?function(C,D){return C===D||!!(C.compareDocumentPosition(D)&16);
-}:function(C,D){if(D){do{if(D===C){return true;}}while((D=D.parentNode));}return false;};p.documentSorter=(z.compareDocumentPosition)?function(D,C){if(!D.compareDocumentPosition||!C.compareDocumentPosition){return 0;
-}return D.compareDocumentPosition(C)&4?-1:D===C?0:1;}:("sourceIndex" in z)?function(D,C){if(!D.sourceIndex||!C.sourceIndex){return 0;}return D.sourceIndex-C.sourceIndex;
-}:(x.createRange)?function(F,D){if(!F.ownerDocument||!D.ownerDocument){return 0;}var E=F.ownerDocument.createRange(),C=D.ownerDocument.createRange();E.setStart(F,0);
-E.setEnd(F,0);C.setStart(D,0);C.setEnd(D,0);return E.compareBoundaryPoints(Range.START_TO_END,C);}:null;z=null;for(B in p){this[B]=p[B];}};var f=/^([#.]?)((?:[\w-]+|\*))$/,h=/\[.+[*$^]=(?:""|'')?\]/,g={};
-k.search=function(U,z,H,s){var p=this.found=(s)?null:(H||[]);if(!U){return p;}else{if(U.navigator){U=U.document;}else{if(!U.nodeType){return p;}}}var F,O,V=this.uniques={},I=!!(H&&H.length),y=(U.nodeType==9);
-if(this.document!==(y?U:U.ownerDocument)){this.setDocument(U);}if(I){for(O=p.length;O--;){V[this.getUID(p[O])]=true;}}if(typeof z=="string"){var r=z.match(f);
-simpleSelectors:if(r){var u=r[1],v=r[2],A,E;if(!u){if(v=="*"&&this.brokenStarGEBTN){break simpleSelectors;}E=U.getElementsByTagName(v);if(s){return E[0]||null;
-}for(O=0;A=E[O++];){if(!(I&&V[this.getUID(A)])){p.push(A);}}}else{if(u=="#"){if(!this.isHTMLDocument||!y){break simpleSelectors;}A=U.getElementById(v);
-if(!A){return p;}if(this.idGetsName&&A.getAttributeNode("id").nodeValue!=v){break simpleSelectors;}if(s){return A||null;}if(!(I&&V[this.getUID(A)])){p.push(A);
-}}else{if(u=="."){if(!this.isHTMLDocument||((!U.getElementsByClassName||this.brokenGEBCN)&&U.querySelectorAll)){break simpleSelectors;}if(U.getElementsByClassName&&!this.brokenGEBCN){E=U.getElementsByClassName(v);
-if(s){return E[0]||null;}for(O=0;A=E[O++];){if(!(I&&V[this.getUID(A)])){p.push(A);}}}else{var T=new RegExp("(^|\\s)"+e.escapeRegExp(v)+"(\\s|$)");E=U.getElementsByTagName("*");
-for(O=0;A=E[O++];){className=A.className;if(!(className&&T.test(className))){continue;}if(s){return A;}if(!(I&&V[this.getUID(A)])){p.push(A);}}}}}}if(I){this.sort(p);
-}return(s)?null:p;}querySelector:if(U.querySelectorAll){if(!this.isHTMLDocument||g[z]||this.brokenMixedCaseQSA||(this.brokenCheckedQSA&&z.indexOf(":checked")>-1)||(this.brokenEmptyAttributeQSA&&h.test(z))||(!y&&z.indexOf(",")>-1)||e.disableQSA){break querySelector;
-}var S=z,x=U;if(!y){var C=x.getAttribute("id"),t="slickid__";x.setAttribute("id",t);S="#"+t+" "+S;U=x.parentNode;}try{if(s){return U.querySelector(S)||null;
-}else{E=U.querySelectorAll(S);}}catch(Q){g[z]=1;break querySelector;}finally{if(!y){if(C){x.setAttribute("id",C);}else{x.removeAttribute("id");}U=x;}}if(this.starSelectsClosedQSA){for(O=0;
-A=E[O++];){if(A.nodeName>"@"&&!(I&&V[this.getUID(A)])){p.push(A);}}}else{for(O=0;A=E[O++];){if(!(I&&V[this.getUID(A)])){p.push(A);}}}if(I){this.sort(p);
-}return p;}F=this.Slick.parse(z);if(!F.length){return p;}}else{if(z==null){return p;}else{if(z.Slick){F=z;}else{if(this.contains(U.documentElement||U,z)){(p)?p.push(z):p=z;
-return p;}else{return p;}}}}this.posNTH={};this.posNTHLast={};this.posNTHType={};this.posNTHTypeLast={};this.push=(!I&&(s||(F.length==1&&F.expressions[0].length==1)))?this.pushArray:this.pushUID;
-if(p==null){p=[];}var M,L,K;var B,J,D,c,q,G,W;var N,P,o,w,R=F.expressions;search:for(O=0;(P=R[O]);O++){for(M=0;(o=P[M]);M++){B="combinator:"+o.combinator;
-if(!this[B]){continue search;}J=(this.isXMLDocument)?o.tag:o.tag.toUpperCase();D=o.id;c=o.classList;q=o.classes;G=o.attributes;W=o.pseudos;w=(M===(P.length-1));
-this.bitUniques={};if(w){this.uniques=V;this.found=p;}else{this.uniques={};this.found=[];}if(M===0){this[B](U,J,D,q,G,W,c);if(s&&w&&p.length){break search;
-}}else{if(s&&w){for(L=0,K=N.length;L<K;L++){this[B](N[L],J,D,q,G,W,c);if(p.length){break search;}}}else{for(L=0,K=N.length;L<K;L++){this[B](N[L],J,D,q,G,W,c);
-}}}N=this.found;}}if(I||(F.expressions.length>1)){this.sort(p);}return(s)?(p[0]||null):p;};k.uidx=1;k.uidk="slick-uniqueid";k.getUIDXML=function(n){var c=n.getAttribute(this.uidk);
-if(!c){c=this.uidx++;n.setAttribute(this.uidk,c);}return c;};k.getUIDHTML=function(c){return c.uniqueNumber||(c.uniqueNumber=this.uidx++);};k.sort=function(c){if(!this.documentSorter){return c;
-}c.sort(this.documentSorter);return c;};k.cacheNTH={};k.matchNTH=/^([+-]?\d*)?([a-z]+)?([+-]\d+)?$/;k.parseNTHArgument=function(q){var o=q.match(this.matchNTH);
-if(!o){return false;}var p=o[2]||false;var n=o[1]||1;if(n=="-"){n=-1;}var c=+o[3]||0;o=(p=="n")?{a:n,b:c}:(p=="odd")?{a:2,b:1}:(p=="even")?{a:2,b:0}:{a:0,b:n};
-return(this.cacheNTH[q]=o);};k.createNTHPseudo=function(p,n,c,o){return function(s,q){var u=this.getUID(s);if(!this[c][u]){var A=s.parentNode;if(!A){return false;
-}var r=A[p],t=1;if(o){var z=s.nodeName;do{if(r.nodeName!=z){continue;}this[c][this.getUID(r)]=t++;}while((r=r[n]));}else{do{if(r.nodeType!=1){continue;
-}this[c][this.getUID(r)]=t++;}while((r=r[n]));}}q=q||"n";var v=this.cacheNTH[q]||this.parseNTHArgument(q);if(!v){return false;}var y=v.a,x=v.b,w=this[c][u];
-if(y==0){return x==w;}if(y>0){if(w<x){return false;}}else{if(x<w){return false;}}return((w-x)%y)==0;};};k.pushArray=function(p,c,r,o,n,q){if(this.matchSelector(p,c,r,o,n,q)){this.found.push(p);
-}};k.pushUID=function(q,c,s,p,n,r){var o=this.getUID(q);if(!this.uniques[o]&&this.matchSelector(q,c,s,p,n,r)){this.uniques[o]=true;this.found.push(q);}};
-k.matchNode=function(n,o){if(this.isHTMLDocument&&this.nativeMatchesSelector){try{return this.nativeMatchesSelector.call(n,o.replace(/\[([^=]+)=\s*([^'"\]]+?)\s*\]/g,'[$1="$2"]'));
-}catch(u){}}var t=this.Slick.parse(o);if(!t){return true;}var r=t.expressions,s=0,q;for(q=0;(currentExpression=r[q]);q++){if(currentExpression.length==1){var p=currentExpression[0];
-if(this.matchSelector(n,(this.isXMLDocument)?p.tag:p.tag.toUpperCase(),p.id,p.classes,p.attributes,p.pseudos)){return true;}s++;}}if(s==t.length){return false;
-}var c=this.search(this.document,t),v;for(q=0;v=c[q++];){if(v===n){return true;}}return false;};k.matchPseudo=function(q,c,p){var n="pseudo:"+c;if(this[n]){return this[n](q,p);
-}var o=this.getAttribute(q,c);return(p)?p==o:!!o;};k.matchSelector=function(o,v,c,p,q,s){if(v){var t=(this.isXMLDocument)?o.nodeName:o.nodeName.toUpperCase();
-if(v=="*"){if(t<"@"){return false;}}else{if(t!=v){return false;}}}if(c&&o.getAttribute("id")!=c){return false;}var r,n,u;if(p){for(r=p.length;r--;){u=o.getAttribute("class")||o.className;
-if(!(u&&p[r].regexp.test(u))){return false;}}}if(q){for(r=q.length;r--;){n=q[r];if(n.operator?!n.test(this.getAttribute(o,n.key)):!this.hasAttribute(o,n.key)){return false;
-}}}if(s){for(r=s.length;r--;){n=s[r];if(!this.matchPseudo(o,n.key,n.value)){return false;}}}return true;};var j={" ":function(q,w,n,r,s,u,p){var t,v,o;
-if(this.isHTMLDocument){getById:if(n){v=this.document.getElementById(n);if((!v&&q.all)||(this.idGetsName&&v&&v.getAttributeNode("id").nodeValue!=n)){o=q.all[n];
-if(!o){return;}if(!o[0]){o=[o];}for(t=0;v=o[t++];){var c=v.getAttributeNode("id");if(c&&c.nodeValue==n){this.push(v,w,null,r,s,u);break;}}return;}if(!v){if(this.contains(this.root,q)){return;
-}else{break getById;}}else{if(this.document!==q&&!this.contains(q,v)){return;}}this.push(v,w,null,r,s,u);return;}getByClass:if(r&&q.getElementsByClassName&&!this.brokenGEBCN){o=q.getElementsByClassName(p.join(" "));
-if(!(o&&o.length)){break getByClass;}for(t=0;v=o[t++];){this.push(v,w,n,null,s,u);}return;}}getByTag:{o=q.getElementsByTagName(w);if(!(o&&o.length)){break getByTag;
-}if(!this.brokenStarGEBTN){w=null;}for(t=0;v=o[t++];){this.push(v,w,n,r,s,u);}}},">":function(p,c,r,o,n,q){if((p=p.firstChild)){do{if(p.nodeType==1){this.push(p,c,r,o,n,q);
-}}while((p=p.nextSibling));}},"+":function(p,c,r,o,n,q){while((p=p.nextSibling)){if(p.nodeType==1){this.push(p,c,r,o,n,q);break;}}},"^":function(p,c,r,o,n,q){p=p.firstChild;
-if(p){if(p.nodeType==1){this.push(p,c,r,o,n,q);}else{this["combinator:+"](p,c,r,o,n,q);}}},"~":function(q,c,s,p,n,r){while((q=q.nextSibling)){if(q.nodeType!=1){continue;
-}var o=this.getUID(q);if(this.bitUniques[o]){break;}this.bitUniques[o]=true;this.push(q,c,s,p,n,r);}},"++":function(p,c,r,o,n,q){this["combinator:+"](p,c,r,o,n,q);
-this["combinator:!+"](p,c,r,o,n,q);},"~~":function(p,c,r,o,n,q){this["combinator:~"](p,c,r,o,n,q);this["combinator:!~"](p,c,r,o,n,q);},"!":function(p,c,r,o,n,q){while((p=p.parentNode)){if(p!==this.document){this.push(p,c,r,o,n,q);
-}}},"!>":function(p,c,r,o,n,q){p=p.parentNode;if(p!==this.document){this.push(p,c,r,o,n,q);}},"!+":function(p,c,r,o,n,q){while((p=p.previousSibling)){if(p.nodeType==1){this.push(p,c,r,o,n,q);
-break;}}},"!^":function(p,c,r,o,n,q){p=p.lastChild;if(p){if(p.nodeType==1){this.push(p,c,r,o,n,q);}else{this["combinator:!+"](p,c,r,o,n,q);}}},"!~":function(q,c,s,p,n,r){while((q=q.previousSibling)){if(q.nodeType!=1){continue;
-}var o=this.getUID(q);if(this.bitUniques[o]){break;}this.bitUniques[o]=true;this.push(q,c,s,p,n,r);}}};for(var i in j){k["combinator:"+i]=j[i];}var l={empty:function(c){var n=c.firstChild;
-return !(n&&n.nodeType==1)&&!(c.innerText||c.textContent||"").length;},not:function(c,n){return !this.matchNode(c,n);},contains:function(c,n){return(c.innerText||c.textContent||"").indexOf(n)>-1;
-},"first-child":function(c){while((c=c.previousSibling)){if(c.nodeType==1){return false;}}return true;},"last-child":function(c){while((c=c.nextSibling)){if(c.nodeType==1){return false;
-}}return true;},"only-child":function(o){var n=o;while((n=n.previousSibling)){if(n.nodeType==1){return false;}}var c=o;while((c=c.nextSibling)){if(c.nodeType==1){return false;
-}}return true;},"nth-child":k.createNTHPseudo("firstChild","nextSibling","posNTH"),"nth-last-child":k.createNTHPseudo("lastChild","previousSibling","posNTHLast"),"nth-of-type":k.createNTHPseudo("firstChild","nextSibling","posNTHType",true),"nth-last-of-type":k.createNTHPseudo("lastChild","previousSibling","posNTHTypeLast",true),index:function(n,c){return this["pseudo:nth-child"](n,""+c+1);
-},even:function(c){return this["pseudo:nth-child"](c,"2n");},odd:function(c){return this["pseudo:nth-child"](c,"2n+1");},"first-of-type":function(c){var n=c.nodeName;
-while((c=c.previousSibling)){if(c.nodeName==n){return false;}}return true;},"last-of-type":function(c){var n=c.nodeName;while((c=c.nextSibling)){if(c.nodeName==n){return false;
-}}return true;},"only-of-type":function(o){var n=o,p=o.nodeName;while((n=n.previousSibling)){if(n.nodeName==p){return false;}}var c=o;while((c=c.nextSibling)){if(c.nodeName==p){return false;
-}}return true;},enabled:function(c){return !c.disabled;},disabled:function(c){return c.disabled;},checked:function(c){return c.checked||c.selected;},focus:function(c){return this.isHTMLDocument&&this.document.activeElement===c&&(c.href||c.type||this.hasAttribute(c,"tabindex"));
-},root:function(c){return(c===this.root);},selected:function(c){return c.selected;}};for(var b in l){k["pseudo:"+b]=l[b];}var a=k.attributeGetters={"class":function(){return this.getAttribute("class")||this.className;
-},"for":function(){return("htmlFor" in this)?this.htmlFor:this.getAttribute("for");},href:function(){return("href" in this)?this.getAttribute("href",2):this.getAttribute("href");
-},style:function(){return(this.style)?this.style.cssText:this.getAttribute("style");},tabindex:function(){var c=this.getAttributeNode("tabindex");return(c&&c.specified)?c.nodeValue:null;
-},type:function(){return this.getAttribute("type");},maxlength:function(){var c=this.getAttributeNode("maxLength");return(c&&c.specified)?c.nodeValue:null;
-}};a.MAXLENGTH=a.maxLength=a.maxlength;var e=k.Slick=(this.Slick||{});e.version="1.1.6";e.search=function(n,o,c){return k.search(n,o,c);};e.find=function(c,n){return k.search(c,n,null,true);
-};e.contains=function(c,n){k.setDocument(c);return k.contains(c,n);};e.getAttribute=function(n,c){k.setDocument(n);return k.getAttribute(n,c);};e.hasAttribute=function(n,c){k.setDocument(n);
-return k.hasAttribute(n,c);};e.match=function(n,c){if(!(n&&c)){return false;}if(!c||c===n){return true;}k.setDocument(n);return k.matchNode(n,c);};e.defineAttributeGetter=function(c,n){k.attributeGetters[c]=n;
-return this;};e.lookupAttributeGetter=function(c){return k.attributeGetters[c];};e.definePseudo=function(c,n){k["pseudo:"+c]=function(p,o){return n.call(p,o);
-};return this;};e.lookupPseudo=function(c){var n=k["pseudo:"+c];if(n){return function(o){return n.call(this,o);};}return null;};e.override=function(n,c){k.override(n,c);
-return this;};e.isXML=k.isXML;e.uidOf=function(c){return k.getUIDHTML(c);};if(!this.Slick){this.Slick=e;}}).apply((typeof exports!="undefined")?exports:this);
-var Element=function(b,g){var h=Element.Constructors[b];if(h){return h(g);}if(typeof b!="string"){return document.id(b).set(g);}if(!g){g={};}if(!(/^[\w-]+$/).test(b)){var e=Slick.parse(b).expressions[0][0];
-b=(e.tag=="*")?"div":e.tag;if(e.id&&g.id==null){g.id=e.id;}var d=e.attributes;if(d){for(var a,f=0,c=d.length;f<c;f++){a=d[f];if(g[a.key]!=null){continue;
-}if(a.value!=null&&a.operator=="="){g[a.key]=a.value;}else{if(!a.value&&!a.operator){g[a.key]=true;}}}}if(e.classList&&g["class"]==null){g["class"]=e.classList.join(" ");
-}}return document.newElement(b,g);};if(Browser.Element){Element.prototype=Browser.Element.prototype;}new Type("Element",Element).mirror(function(a){if(Array.prototype[a]){return;
-}var b={};b[a]=function(){var h=[],e=arguments,j=true;for(var g=0,d=this.length;g<d;g++){var f=this[g],c=h[g]=f[a].apply(f,e);j=(j&&typeOf(c)=="element");
-}return(j)?new Elements(h):h;};Elements.implement(b);});if(!Browser.Element){Element.parent=Object;Element.Prototype={"$family":Function.from("element").hide()};
-Element.mirror(function(a,b){Element.Prototype[a]=b;});}Element.Constructors={};var IFrame=new Type("IFrame",function(){var e=Array.link(arguments,{properties:Type.isObject,iframe:function(f){return(f!=null);
-}});var c=e.properties||{},b;if(e.iframe){b=document.id(e.iframe);}var d=c.onload||function(){};delete c.onload;c.id=c.name=[c.id,c.name,b?(b.id||b.name):"IFrame_"+String.uniqueID()].pick();
-b=new Element(b||"iframe",c);var a=function(){d.call(b.contentWindow);};if(window.frames[c.id]){a();}else{b.addListener("load",a);}return b;});var Elements=this.Elements=function(a){if(a&&a.length){var e={},d;
-for(var c=0;d=a[c++];){var b=Slick.uidOf(d);if(!e[b]){e[b]=true;this.push(d);}}}};Elements.prototype={length:0};Elements.parent=Array;new Type("Elements",Elements).implement({filter:function(a,b){if(!a){return this;
-}return new Elements(Array.filter(this,(typeOf(a)=="string")?function(c){return c.match(a);}:a,b));}.protect(),push:function(){var d=this.length;for(var b=0,a=arguments.length;
-b<a;b++){var c=document.id(arguments[b]);if(c){this[d++]=c;}}return(this.length=d);}.protect(),unshift:function(){var b=[];for(var c=0,a=arguments.length;
-c<a;c++){var d=document.id(arguments[c]);if(d){b.push(d);}}return Array.prototype.unshift.apply(this,b);}.protect(),concat:function(){var b=new Elements(this);
-for(var c=0,a=arguments.length;c<a;c++){var d=arguments[c];if(Type.isEnumerable(d)){b.append(d);}else{b.push(d);}}return b;}.protect(),append:function(c){for(var b=0,a=c.length;
-b<a;b++){this.push(c[b]);}return this;}.protect(),empty:function(){while(this.length){delete this[--this.length];}return this;}.protect()});(function(){var g=Array.prototype.splice,b={"0":0,"1":1,length:2};
-g.call(b,1,1);if(b[1]==1){Elements.implement("splice",function(){var h=this.length;var e=g.apply(this,arguments);while(h>=this.length){delete this[h--];
-}return e;}.protect());}Elements.implement(Array.prototype);Array.mirror(Elements);var f;try{var a=document.createElement("<input name=x>");f=(a.name=="x");
-}catch(c){}var d=function(e){return(""+e).replace(/&/g,"&amp;").replace(/"/g,"&quot;");};Document.implement({newElement:function(e,h){if(h&&h.checked!=null){h.defaultChecked=h.checked;
-}if(f&&h){e="<"+e;if(h.name){e+=' name="'+d(h.name)+'"';}if(h.type){e+=' type="'+d(h.type)+'"';}e+=">";delete h.name;delete h.type;}return this.id(this.createElement(e)).set(h);
-}});})();Document.implement({newTextNode:function(a){return this.createTextNode(a);},getDocument:function(){return this;},getWindow:function(){return this.window;
-},id:(function(){var a={string:function(d,c,b){d=Slick.find(b,"#"+d.replace(/(\W)/g,"\\$1"));return(d)?a.element(d,c):null;},element:function(b,c){$uid(b);
-if(!c&&!b.$family&&!(/^(?:object|embed)$/i).test(b.tagName)){Object.append(b,Element.Prototype);}return b;},object:function(c,d,b){if(c.toElement){return a.element(c.toElement(b),d);
-}return null;}};a.textnode=a.whitespace=a.window=a.document=function(b){return b;};return function(c,e,d){if(c&&c.$family&&c.uid){return c;}var b=typeOf(c);
-return(a[b])?a[b](c,e,d||document):null;};})()});if(window.$==null){Window.implement("$",function(a,b){return document.id(a,b,this.document);});}Window.implement({getDocument:function(){return this.document;
-},getWindow:function(){return this;}});[Document,Element].invoke("implement",{getElements:function(a){return Slick.search(this,a,new Elements);},getElement:function(a){return document.id(Slick.find(this,a));
-}});var contains={contains:function(a){return Slick.contains(this,a);}};if(!document.contains){Document.implement(contains);}if(!document.createElement("div").contains){Element.implement(contains);
-}var injectCombinator=function(d,c){if(!d){return c;}d=Object.clone(Slick.parse(d));var b=d.expressions;for(var a=b.length;a--;){b[a][0].combinator=c;}return d;
-};Object.forEach({getNext:"~",getPrevious:"!~",getParent:"!"},function(a,b){Element.implement(b,function(c){return this.getElement(injectCombinator(c,a));
-});});Object.forEach({getAllNext:"~",getAllPrevious:"!~",getSiblings:"~~",getChildren:">",getParents:"!"},function(a,b){Element.implement(b,function(c){return this.getElements(injectCombinator(c,a));
-});});Element.implement({getFirst:function(a){return document.id(Slick.search(this,injectCombinator(a,">"))[0]);},getLast:function(a){return document.id(Slick.search(this,injectCombinator(a,">")).getLast());
-},getWindow:function(){return this.ownerDocument.window;},getDocument:function(){return this.ownerDocument;},getElementById:function(a){return document.id(Slick.find(this,"#"+(""+a).replace(/(\W)/g,"\\$1")));
-},match:function(a){return !a||Slick.match(this,a);}});if(window.$$==null){Window.implement("$$",function(a){if(arguments.length==1){if(typeof a=="string"){return Slick.search(this.document,a,new Elements);
-}else{if(Type.isEnumerable(a)){return new Elements(a);}}}return new Elements(arguments);});}(function(){var b={before:function(n,m){var o=m.parentNode;
-if(o){o.insertBefore(n,m);}},after:function(n,m){var o=m.parentNode;if(o){o.insertBefore(n,m.nextSibling);}},bottom:function(n,m){m.appendChild(n);},top:function(n,m){m.insertBefore(n,m.firstChild);
-}};b.inside=b.bottom;var k={},d={};var i={};Array.forEach(["type","value","defaultValue","accessKey","cellPadding","cellSpacing","colSpan","frameBorder","readOnly","rowSpan","tabIndex","useMap"],function(m){i[m.toLowerCase()]=m;
-});Object.append(i,{html:"innerHTML",text:(function(){var m=document.createElement("div");return(m.textContent==null)?"innerText":"textContent";})()});
-Object.forEach(i,function(n,m){d[m]=function(o,p){o[n]=p;};k[m]=function(o){return o[n];};});var a=["compact","nowrap","ismap","declare","noshade","checked","disabled","readOnly","multiple","selected","noresize","defer","defaultChecked","autofocus","controls","autoplay","loop"];
-var h={};Array.forEach(a,function(m){var n=m.toLowerCase();h[n]=m;d[n]=function(o,p){o[m]=!!p;};k[n]=function(o){return !!o[m];};});Object.append(d,{"class":function(m,n){("className" in m)?m.className=n:m.setAttribute("class",n);
-},"for":function(m,n){("htmlFor" in m)?m.htmlFor=n:m.setAttribute("for",n);},style:function(m,n){(m.style)?m.style.cssText=n:m.setAttribute("style",n);
-}});Element.implement({setProperty:function(n,o){var m=n.toLowerCase();if(o==null){if(!h[m]){this.removeAttribute(n);return this;}o=false;}var p=d[m];if(p){p(this,o);
-}else{this.setAttribute(n,o);}return this;},setProperties:function(m){for(var n in m){this.setProperty(n,m[n]);}return this;},getProperty:function(o){var n=k[o.toLowerCase()];
-if(n){return n(this);}var m=Slick.getAttribute(this,o);return(!m&&!Slick.hasAttribute(this,o))?null:m;},getProperties:function(){var m=Array.from(arguments);
-return m.map(this.getProperty,this).associate(m);},removeProperty:function(m){return this.setProperty(m,null);},removeProperties:function(){Array.each(arguments,this.removeProperty,this);
-return this;},set:function(o,n){var m=Element.Properties[o];(m&&m.set)?m.set.call(this,n):this.setProperty(o,n);}.overloadSetter(),get:function(n){var m=Element.Properties[n];
-return(m&&m.get)?m.get.apply(this):this.getProperty(n);}.overloadGetter(),erase:function(n){var m=Element.Properties[n];(m&&m.erase)?m.erase.apply(this):this.removeProperty(n);
-return this;},hasClass:function(m){return this.className.clean().contains(m," ");},addClass:function(m){if(!this.hasClass(m)){this.className=(this.className+" "+m).clean();
-}return this;},removeClass:function(m){this.className=this.className.replace(new RegExp("(^|\\s)"+m+"(?:\\s|$)"),"$1");return this;},toggleClass:function(m,n){if(n==null){n=!this.hasClass(m);
-}return(n)?this.addClass(m):this.removeClass(m);},adopt:function(){var p=this,m,r=Array.flatten(arguments),q=r.length;if(q>1){p=m=document.createDocumentFragment();
-}for(var o=0;o<q;o++){var n=document.id(r[o],true);if(n){p.appendChild(n);}}if(m){this.appendChild(m);}return this;},appendText:function(n,m){return this.grab(this.getDocument().newTextNode(n),m);
-},grab:function(n,m){b[m||"bottom"](document.id(n,true),this);return this;},inject:function(n,m){b[m||"bottom"](this,document.id(n,true));return this;},replaces:function(m){m=document.id(m,true);
-m.parentNode.replaceChild(this,m);return this;},wraps:function(n,m){n=document.id(n,true);return this.replaces(n).grab(n,m);},getSelected:function(){this.selectedIndex;
-return new Elements(Array.from(this.options).filter(function(m){return m.selected;}));},toQueryString:function(){var m=[];this.getElements("input, select, textarea").each(function(o){var n=o.type;
-if(!o.name||o.disabled||n=="submit"||n=="reset"||n=="file"||n=="image"){return;}var p=(o.get("tag")=="select")?o.getSelected().map(function(q){return document.id(q).get("value");
-}):((n=="radio"||n=="checkbox")&&!o.checked)?null:o.get("value");Array.from(p).each(function(q){if(typeof q!="undefined"){m.push(encodeURIComponent(o.name)+"="+encodeURIComponent(q));
-}});});return m.join("&");}});var j={},e={};var c=function(m){return(e[m]||(e[m]={}));};var g=function(n){var m=n.uid;if(n.removeEvents){n.removeEvents();
-}if(n.clearAttributes){n.clearAttributes();}if(m!=null){delete j[m];delete e[m];}return n;};var l={input:"checked",option:"selected",textarea:"value"};
-Element.implement({destroy:function(){var m=g(this).getElementsByTagName("*");Array.each(m,g);Element.dispose(this);return null;},empty:function(){Array.from(this.childNodes).each(Element.dispose);
-return this;},dispose:function(){return(this.parentNode)?this.parentNode.removeChild(this):this;},clone:function(r,p){r=r!==false;var w=this.cloneNode(r),o=[w],q=[this],u;
-if(r){o.append(Array.from(w.getElementsByTagName("*")));q.append(Array.from(this.getElementsByTagName("*")));}for(u=o.length;u--;){var s=o[u],v=q[u];if(!p){s.removeAttribute("id");
-}if(s.clearAttributes){s.clearAttributes();s.mergeAttributes(v);s.removeAttribute("uid");if(s.options){var z=s.options,m=v.options;for(var t=z.length;t--;
-){z[t].selected=m[t].selected;}}}var n=l[v.tagName.toLowerCase()];if(n&&v[n]){s[n]=v[n];}}if(Browser.ie){var x=w.getElementsByTagName("object"),y=this.getElementsByTagName("object");
-for(u=x.length;u--;){x[u].outerHTML=y[u].outerHTML;}}return document.id(w);}});[Element,Window,Document].invoke("implement",{addListener:function(p,o){if(p=="unload"){var m=o,n=this;
-o=function(){n.removeListener("unload",o);m();};}else{j[$uid(this)]=this;}if(this.addEventListener){this.addEventListener(p,o,!!arguments[2]);}else{this.attachEvent("on"+p,o);
-}return this;},removeListener:function(n,m){if(this.removeEventListener){this.removeEventListener(n,m,!!arguments[2]);}else{this.detachEvent("on"+n,m);
-}return this;},retrieve:function(n,m){var p=c($uid(this)),o=p[n];if(m!=null&&o==null){o=p[n]=m;}return o!=null?o:null;},store:function(n,m){var o=c($uid(this));
-o[n]=m;return this;},eliminate:function(m){var n=c($uid(this));delete n[m];return this;}});if(window.attachEvent&&!window.addEventListener){window.addListener("unload",function(){Object.each(j,g);
-if(window.CollectGarbage){CollectGarbage();}});}Element.Properties={};Element.Properties.style={set:function(m){this.style.cssText=m;},get:function(){return this.style.cssText;
-},erase:function(){this.style.cssText="";}};Element.Properties.tag={get:function(){return this.tagName.toLowerCase();}};Element.Properties.html=(function(){var s=Function.attempt(function(){var u=document.createElement("table");
-u.innerHTML="<tr><td></td></tr>";});var t=document.createElement("div");var o={table:[1,"<table>","</table>"],select:[1,"<select>","</select>"],tbody:[2,"<table><tbody>","</tbody></table>"],tr:[3,"<table><tbody><tr>","</tr></tbody></table>"]};
-o.thead=o.tfoot=o.tbody;t.innerHTML="<nav></nav>";var n=t.childNodes.length==1;if(!n){var q="abbr article aside audio canvas datalist details figcaption figure footer header hgroup mark meter nav output progress section summary time video".split(" "),p=document.createDocumentFragment(),m=q.length;
-while(m--){p.createElement(q[m]);}p.appendChild(t);}var r={set:function(v){if(typeOf(v)=="array"){v=v.join("");}var w=(!s&&o[this.get("tag")]);if(!w&&!n){w=[0,"",""];
-}if(w){var x=t;x.innerHTML=w[1]+v+w[2];for(var u=w[0];u--;){x=x.firstChild;}this.empty().adopt(x.childNodes);}else{this.innerHTML=v;}}};r.erase=r.set;return r;
-})();var f=document.createElement("form");f.innerHTML="<select><option>s</option></select>";if(f.firstChild.value!="s"){Element.Properties.value={set:function(r){var n=this.get("tag");
-if(n!="select"){return this.setProperty("value",r);}var o=this.getElements("option");for(var p=0;p<o.length;p++){var q=o[p],m=q.getAttributeNode("value"),s=(m&&m.specified)?q.value:q.get("text");
-if(s==r){return q.selected=true;}}},get:function(){var o=this,n=o.get("tag");if(n!="select"&&n!="option"){return this.getProperty("value");}if(n=="select"&&!(o=o.getSelected()[0])){return"";
-}var m=o.getAttributeNode("value");return(m&&m.specified)?o.value:o.get("text");}};}})();(function(){var f=document.html;Element.Properties.styles={set:function(i){this.setStyles(i);
-}};var h=(f.style.opacity!=null),a=(f.style.filter!=null),g=/alpha\(opacity=([\d.]+)\)/i;var b=function(j,i){j.store("$opacity",i);j.style.visibility=i>0?"visible":"hidden";
-};var d=(h?function(j,i){j.style.opacity=i;}:(a?function(j,i){if(!j.currentStyle||!j.currentStyle.hasLayout){j.style.zoom=1;}i=(i*100).limit(0,100).round();
-i=(i==100)?"":"alpha(opacity="+i+")";var k=j.style.filter||j.getComputedStyle("filter")||"";j.style.filter=g.test(k)?k.replace(g,i):k+i;}:b));var e=(h?function(j){var i=j.style.opacity||j.getComputedStyle("opacity");
-return(i=="")?1:i.toFloat();}:(a?function(j){var k=(j.style.filter||j.getComputedStyle("filter")),i;if(k){i=k.match(g);}return(i==null||k==null)?1:(i[1]/100);
-}:function(j){var i=j.retrieve("$opacity");if(i==null){i=(j.style.visibility=="hidden"?0:1);}return i;}));var c=(f.style.cssFloat==null)?"styleFloat":"cssFloat";
-Element.implement({getComputedStyle:function(k){if(this.currentStyle){return this.currentStyle[k.camelCase()];}var j=Element.getDocument(this).defaultView,i=j?j.getComputedStyle(this,null):null;
-return(i)?i.getPropertyValue((k==c)?"float":k.hyphenate()):null;},setStyle:function(j,i){if(j=="opacity"){d(this,parseFloat(i));return this;}j=(j=="float"?c:j).camelCase();
-if(typeOf(i)!="string"){var k=(Element.Styles[j]||"@").split(" ");i=Array.from(i).map(function(m,l){if(!k[l]){return"";}return(typeOf(m)=="number")?k[l].replace("@",Math.round(m)):m;
-}).join(" ");}else{if(i==String(Number(i))){i=Math.round(i);}}this.style[j]=i;return this;},getStyle:function(o){if(o=="opacity"){return e(this);}o=(o=="float"?c:o).camelCase();
-var i=this.style[o];if(!i||o=="zIndex"){i=[];for(var n in Element.ShortStyles){if(o!=n){continue;}for(var m in Element.ShortStyles[n]){i.push(this.getStyle(m));
-}return i.join(" ");}i=this.getComputedStyle(o);}if(i){i=String(i);var k=i.match(/rgba?\([\d\s,]+\)/);if(k){i=i.replace(k[0],k[0].rgbToHex());}}if(Browser.opera||(Browser.ie&&isNaN(parseFloat(i)))){if((/^(height|width)$/).test(o)){var j=(o=="width")?["left","right"]:["top","bottom"],l=0;
-j.each(function(p){l+=this.getStyle("border-"+p+"-width").toInt()+this.getStyle("padding-"+p).toInt();},this);return this["offset"+o.capitalize()]-l+"px";
-}if(Browser.opera&&String(i).indexOf("px")!=-1){return i;}if((/^border(.+)Width|margin|padding/).test(o)){return"0px";}}return i;},setStyles:function(j){for(var i in j){this.setStyle(i,j[i]);
-}return this;},getStyles:function(){var i={};Array.flatten(arguments).each(function(j){i[j]=this.getStyle(j);},this);return i;}});Element.Styles={left:"@px",top:"@px",bottom:"@px",right:"@px",width:"@px",height:"@px",maxWidth:"@px",maxHeight:"@px",minWidth:"@px",minHeight:"@px",backgroundColor:"rgb(@, @, @)",backgroundPosition:"@px @px",color:"rgb(@, @, @)",fontSize:"@px",letterSpacing:"@px",lineHeight:"@px",clip:"rect(@px @px @px @px)",margin:"@px @px @px @px",padding:"@px @px @px @px",border:"@px @ rgb(@, @, @) @px @ rgb(@, @, @) @px @ rgb(@, @, @)",borderWidth:"@px @px @px @px",borderStyle:"@ @ @ @",borderColor:"rgb(@, @, @) rgb(@, @, @) rgb(@, @, @) rgb(@, @, @)",zIndex:"@",zoom:"@",fontWeight:"@",textIndent:"@px",opacity:"@"};
-Element.ShortStyles={margin:{},padding:{},border:{},borderWidth:{},borderStyle:{},borderColor:{}};["Top","Right","Bottom","Left"].each(function(o){var n=Element.ShortStyles;
-var j=Element.Styles;["margin","padding"].each(function(p){var q=p+o;n[p][q]=j[q]="@px";});var m="border"+o;n.border[m]=j[m]="@px @ rgb(@, @, @)";var l=m+"Width",i=m+"Style",k=m+"Color";
-n[m]={};n.borderWidth[l]=n[m][l]=j[l]="@px";n.borderStyle[i]=n[m][i]=j[i]="@";n.borderColor[k]=n[m][k]=j[k]="rgb(@, @, @)";});})();(function(){Element.Properties.events={set:function(b){this.addEvents(b);
-}};[Element,Window,Document].invoke("implement",{addEvent:function(f,h){var i=this.retrieve("events",{});if(!i[f]){i[f]={keys:[],values:[]};}if(i[f].keys.contains(h)){return this;
-}i[f].keys.push(h);var g=f,b=Element.Events[f],d=h,j=this;if(b){if(b.onAdd){b.onAdd.call(this,h,f);}if(b.condition){d=function(k){if(b.condition.call(this,k,f)){return h.call(this,k);
-}return true;};}if(b.base){g=Function.from(b.base).call(this,f);}}var e=function(){return h.call(j);};var c=Element.NativeEvents[g];if(c){if(c==2){e=function(k){k=new DOMEvent(k,j.getWindow());
-if(d.call(j,k)===false){k.stop();}};}this.addListener(g,e,arguments[2]);}i[f].values.push(e);return this;},removeEvent:function(e,d){var c=this.retrieve("events");
-if(!c||!c[e]){return this;}var h=c[e];var b=h.keys.indexOf(d);if(b==-1){return this;}var g=h.values[b];delete h.keys[b];delete h.values[b];var f=Element.Events[e];
-if(f){if(f.onRemove){f.onRemove.call(this,d,e);}if(f.base){e=Function.from(f.base).call(this,e);}}return(Element.NativeEvents[e])?this.removeListener(e,g,arguments[2]):this;
-},addEvents:function(b){for(var c in b){this.addEvent(c,b[c]);}return this;},removeEvents:function(b){var d;if(typeOf(b)=="object"){for(d in b){this.removeEvent(d,b[d]);
-}return this;}var c=this.retrieve("events");if(!c){return this;}if(!b){for(d in c){this.removeEvents(d);}this.eliminate("events");}else{if(c[b]){c[b].keys.each(function(e){this.removeEvent(b,e);
-},this);delete c[b];}}return this;},fireEvent:function(e,c,b){var d=this.retrieve("events");if(!d||!d[e]){return this;}c=Array.from(c);d[e].keys.each(function(f){if(b){f.delay(b,this,c);
-}else{f.apply(this,c);}},this);return this;},cloneEvents:function(e,d){e=document.id(e);var c=e.retrieve("events");if(!c){return this;}if(!d){for(var b in c){this.cloneEvents(e,b);
-}}else{if(c[d]){c[d].keys.each(function(f){this.addEvent(d,f);},this);}}return this;}});Element.NativeEvents={click:2,dblclick:2,mouseup:2,mousedown:2,contextmenu:2,mousewheel:2,DOMMouseScroll:2,mouseover:2,mouseout:2,mousemove:2,selectstart:2,selectend:2,keydown:2,keypress:2,keyup:2,orientationchange:2,touchstart:2,touchmove:2,touchend:2,touchcancel:2,gesturestart:2,gesturechange:2,gestureend:2,focus:2,blur:2,change:2,reset:2,select:2,submit:2,paste:2,input:2,load:2,unload:1,beforeunload:2,resize:1,move:1,DOMContentLoaded:1,readystatechange:1,error:1,abort:1,scroll:1};
-var a=function(b){var c=b.relatedTarget;if(c==null){return true;}if(!c){return false;}return(c!=this&&c.prefix!="xul"&&typeOf(this)!="document"&&!this.contains(c));
-};Element.Events={mouseenter:{base:"mouseover",condition:a},mouseleave:{base:"mouseout",condition:a},mousewheel:{base:(Browser.firefox)?"DOMMouseScroll":"mousewheel"}};
-if(!window.addEventListener){Element.NativeEvents.propertychange=2;Element.Events.change={base:function(){var b=this.type;return(this.get("tag")=="input"&&(b=="radio"||b=="checkbox"))?"propertychange":"change";
-},condition:function(b){return !!(this.type!="radio"||this.checked);}};}})();(function(){var c=!!window.addEventListener;Element.NativeEvents.focusin=Element.NativeEvents.focusout=2;
-var k=function(l,m,n,o,p){while(p&&p!=l){if(m(p,o)){return n.call(p,o,p);}p=document.id(p.parentNode);}};var a={mouseenter:{base:"mouseover"},mouseleave:{base:"mouseout"},focus:{base:"focus"+(c?"":"in"),capture:true},blur:{base:c?"blur":"focusout",capture:true}};
-var b="$delegation:";var i=function(l){return{base:"focusin",remove:function(m,o){var p=m.retrieve(b+l+"listeners",{})[o];if(p&&p.forms){for(var n=p.forms.length;
-n--;){p.forms[n].removeEvent(l,p.fns[n]);}}},listen:function(x,r,v,n,t,s){var o=(t.get("tag")=="form")?t:n.target.getParent("form");if(!o){return;}var u=x.retrieve(b+l+"listeners",{}),p=u[s]||{forms:[],fns:[]},m=p.forms,w=p.fns;
-if(m.indexOf(o)!=-1){return;}m.push(o);var q=function(y){k(x,r,v,y,t);};o.addEvent(l,q);w.push(q);u[s]=p;x.store(b+l+"listeners",u);}};};var d=function(l){return{base:"focusin",listen:function(m,n,p,q,r){var o={blur:function(){this.removeEvents(o);
-}};o[l]=function(s){k(m,n,p,s,r);};q.target.addEvents(o);}};};if(!c){Object.append(a,{submit:i("submit"),reset:i("reset"),change:d("change"),select:d("select")});
-}var h=Element.prototype,f=h.addEvent,j=h.removeEvent;var e=function(l,m){return function(r,q,n){if(r.indexOf(":relay")==-1){return l.call(this,r,q,n);
-}var o=Slick.parse(r).expressions[0][0];if(o.pseudos[0].key!="relay"){return l.call(this,r,q,n);}var p=o.tag;o.pseudos.slice(1).each(function(s){p+=":"+s.key+(s.value?"("+s.value+")":"");
-});l.call(this,r,q);return m.call(this,p,o.pseudos[0].value,q);};};var g={addEvent:function(v,q,x){var t=this.retrieve("$delegates",{}),r=t[v];if(r){for(var y in r){if(r[y].fn==x&&r[y].match==q){return this;
-}}}var p=v,u=q,o=x,n=a[v]||{};v=n.base||p;q=function(B){return Slick.match(B,u);};var w=Element.Events[p];if(w&&w.condition){var l=q,m=w.condition;q=function(C,B){return l(C,B)&&m.call(C,B,v);
-};}var z=this,s=String.uniqueID();var A=n.listen?function(B,C){if(!C&&B&&B.target){C=B.target;}if(C){n.listen(z,q,x,B,C,s);}}:function(B,C){if(!C&&B&&B.target){C=B.target;
-}if(C){k(z,q,x,B,C);}};if(!r){r={};}r[s]={match:u,fn:o,delegator:A};t[p]=r;return f.call(this,v,A,n.capture);},removeEvent:function(r,n,t,u){var q=this.retrieve("$delegates",{}),p=q[r];
-if(!p){return this;}if(u){var m=r,w=p[u].delegator,l=a[r]||{};r=l.base||m;if(l.remove){l.remove(this,u);}delete p[u];q[m]=p;return j.call(this,r,w);}var o,v;
-if(t){for(o in p){v=p[o];if(v.match==n&&v.fn==t){return g.removeEvent.call(this,r,n,t,o);}}}else{for(o in p){v=p[o];if(v.match==n){g.removeEvent.call(this,r,n,v.fn,o);
-}}}return this;}};[Element,Window,Document].invoke("implement",{addEvent:e(f,g.addEvent),removeEvent:e(j,g.removeEvent)});})();(function(){var h=document.createElement("div"),e=document.createElement("div");
-h.style.height="0";h.appendChild(e);var d=(e.offsetParent===h);h=e=null;var l=function(m){return k(m,"position")!="static"||a(m);};var i=function(m){return l(m)||(/^(?:table|td|th)$/i).test(m.tagName);
-};Element.implement({scrollTo:function(m,n){if(a(this)){this.getWindow().scrollTo(m,n);}else{this.scrollLeft=m;this.scrollTop=n;}return this;},getSize:function(){if(a(this)){return this.getWindow().getSize();
-}return{x:this.offsetWidth,y:this.offsetHeight};},getScrollSize:function(){if(a(this)){return this.getWindow().getScrollSize();}return{x:this.scrollWidth,y:this.scrollHeight};
-},getScroll:function(){if(a(this)){return this.getWindow().getScroll();}return{x:this.scrollLeft,y:this.scrollTop};},getScrolls:function(){var n=this.parentNode,m={x:0,y:0};
-while(n&&!a(n)){m.x+=n.scrollLeft;m.y+=n.scrollTop;n=n.parentNode;}return m;},getOffsetParent:d?function(){var m=this;if(a(m)||k(m,"position")=="fixed"){return null;
-}var n=(k(m,"position")=="static")?i:l;while((m=m.parentNode)){if(n(m)){return m;}}return null;}:function(){var m=this;if(a(m)||k(m,"position")=="fixed"){return null;
-}try{return m.offsetParent;}catch(n){}return null;},getOffsets:function(){if(this.getBoundingClientRect&&!Browser.Platform.ios){var r=this.getBoundingClientRect(),o=document.id(this.getDocument().documentElement),q=o.getScroll(),t=this.getScrolls(),s=(k(this,"position")=="fixed");
-return{x:r.left.toInt()+t.x+((s)?0:q.x)-o.clientLeft,y:r.top.toInt()+t.y+((s)?0:q.y)-o.clientTop};}var n=this,m={x:0,y:0};if(a(this)){return m;}while(n&&!a(n)){m.x+=n.offsetLeft;
-m.y+=n.offsetTop;if(Browser.firefox){if(!c(n)){m.x+=b(n);m.y+=g(n);}var p=n.parentNode;if(p&&k(p,"overflow")!="visible"){m.x+=b(p);m.y+=g(p);}}else{if(n!=this&&Browser.safari){m.x+=b(n);
-m.y+=g(n);}}n=n.offsetParent;}if(Browser.firefox&&!c(this)){m.x-=b(this);m.y-=g(this);}return m;},getPosition:function(p){var q=this.getOffsets(),n=this.getScrolls();
-var m={x:q.x-n.x,y:q.y-n.y};if(p&&(p=document.id(p))){var o=p.getPosition();return{x:m.x-o.x-b(p),y:m.y-o.y-g(p)};}return m;},getCoordinates:function(o){if(a(this)){return this.getWindow().getCoordinates();
-}var m=this.getPosition(o),n=this.getSize();var p={left:m.x,top:m.y,width:n.x,height:n.y};p.right=p.left+p.width;p.bottom=p.top+p.height;return p;},computePosition:function(m){return{left:m.x-j(this,"margin-left"),top:m.y-j(this,"margin-top")};
-},setPosition:function(m){return this.setStyles(this.computePosition(m));}});[Document,Window].invoke("implement",{getSize:function(){var m=f(this);return{x:m.clientWidth,y:m.clientHeight};
-},getScroll:function(){var n=this.getWindow(),m=f(this);return{x:n.pageXOffset||m.scrollLeft,y:n.pageYOffset||m.scrollTop};},getScrollSize:function(){var o=f(this),n=this.getSize(),m=this.getDocument().body;
-return{x:Math.max(o.scrollWidth,m.scrollWidth,n.x),y:Math.max(o.scrollHeight,m.scrollHeight,n.y)};},getPosition:function(){return{x:0,y:0};},getCoordinates:function(){var m=this.getSize();
-return{top:0,left:0,bottom:m.y,right:m.x,height:m.y,width:m.x};}});var k=Element.getComputedStyle;function j(m,n){return k(m,n).toInt()||0;}function c(m){return k(m,"-moz-box-sizing")=="border-box";
-}function g(m){return j(m,"border-top-width");}function b(m){return j(m,"border-left-width");}function a(m){return(/^(?:body|html)$/i).test(m.tagName);
-}function f(m){var n=m.getDocument();return(!n.compatMode||n.compatMode=="CSS1Compat")?n.html:n.body;}})();Element.alias({position:"setPosition"});[Window,Document,Element].invoke("implement",{getHeight:function(){return this.getSize().y;
-},getWidth:function(){return this.getSize().x;},getScrollTop:function(){return this.getScroll().y;},getScrollLeft:function(){return this.getScroll().x;
-},getScrollHeight:function(){return this.getScrollSize().y;},getScrollWidth:function(){return this.getScrollSize().x;},getTop:function(){return this.getPosition().y;
-},getLeft:function(){return this.getPosition().x;}});(function(){var f=this.Fx=new Class({Implements:[Chain,Events,Options],options:{fps:60,unit:false,duration:500,frames:null,frameSkip:true,link:"ignore"},initialize:function(g){this.subject=this.subject||this;
-this.setOptions(g);},getTransition:function(){return function(g){return -(Math.cos(Math.PI*g)-1)/2;};},step:function(g){if(this.options.frameSkip){var h=(this.time!=null)?(g-this.time):0,i=h/this.frameInterval;
-this.time=g;this.frame+=i;}else{this.frame++;}if(this.frame<this.frames){var j=this.transition(this.frame/this.frames);this.set(this.compute(this.from,this.to,j));
-}else{this.frame=this.frames;this.set(this.compute(this.from,this.to,1));this.stop();}},set:function(g){return g;},compute:function(i,h,g){return f.compute(i,h,g);
-},check:function(){if(!this.isRunning()){return true;}switch(this.options.link){case"cancel":this.cancel();return true;case"chain":this.chain(this.caller.pass(arguments,this));
-return false;}return false;},start:function(k,j){if(!this.check(k,j)){return this;}this.from=k;this.to=j;this.frame=(this.options.frameSkip)?0:-1;this.time=null;
-this.transition=this.getTransition();var i=this.options.frames,h=this.options.fps,g=this.options.duration;this.duration=f.Durations[g]||g.toInt();this.frameInterval=1000/h;
-this.frames=i||Math.round(this.duration/this.frameInterval);this.fireEvent("start",this.subject);b.call(this,h);return this;},stop:function(){if(this.isRunning()){this.time=null;
-d.call(this,this.options.fps);if(this.frames==this.frame){this.fireEvent("complete",this.subject);if(!this.callChain()){this.fireEvent("chainComplete",this.subject);
-}}else{this.fireEvent("stop",this.subject);}}return this;},cancel:function(){if(this.isRunning()){this.time=null;d.call(this,this.options.fps);this.frame=this.frames;
-this.fireEvent("cancel",this.subject).clearChain();}return this;},pause:function(){if(this.isRunning()){this.time=null;d.call(this,this.options.fps);}return this;
-},resume:function(){if((this.frame<this.frames)&&!this.isRunning()){b.call(this,this.options.fps);}return this;},isRunning:function(){var g=e[this.options.fps];
-return g&&g.contains(this);}});f.compute=function(i,h,g){return(h-i)*g+i;};f.Durations={"short":250,normal:500,"long":1000};var e={},c={};var a=function(){var h=Date.now();
-for(var j=this.length;j--;){var g=this[j];if(g){g.step(h);}}};var b=function(h){var g=e[h]||(e[h]=[]);g.push(this);if(!c[h]){c[h]=a.periodical(Math.round(1000/h),g);
-}};var d=function(h){var g=e[h];if(g){g.erase(this);if(!g.length&&c[h]){delete e[h];c[h]=clearInterval(c[h]);}}};})();Fx.CSS=new Class({Extends:Fx,prepare:function(c,d,b){b=Array.from(b);
-if(b[1]==null){b[1]=b[0];b[0]=c.getStyle(d);}var a=b.map(this.parse);return{from:a[0],to:a[1]};},parse:function(a){a=Function.from(a)();a=(typeof a=="string")?a.split(" "):Array.from(a);
-return a.map(function(c){c=String(c);var b=false;Object.each(Fx.CSS.Parsers,function(f,e){if(b){return;}var d=f.parse(c);if(d||d===0){b={value:d,parser:f};
-}});b=b||{value:c,parser:Fx.CSS.Parsers.String};return b;});},compute:function(d,c,b){var a=[];(Math.min(d.length,c.length)).times(function(e){a.push({value:d[e].parser.compute(d[e].value,c[e].value,b),parser:d[e].parser});
-});a.$family=Function.from("fx:css:value");return a;},serve:function(c,b){if(typeOf(c)!="fx:css:value"){c=this.parse(c);}var a=[];c.each(function(d){a=a.concat(d.parser.serve(d.value,b));
-});return a;},render:function(a,d,c,b){a.setStyle(d,this.serve(c,b));},search:function(a){if(Fx.CSS.Cache[a]){return Fx.CSS.Cache[a];}var c={},b=new RegExp("^"+a.escapeRegExp()+"$");
-Array.each(document.styleSheets,function(f,e){var d=f.href;if(d&&d.contains("://")&&!d.contains(document.domain)){return;}var g=f.rules||f.cssRules;Array.each(g,function(k,h){if(!k.style){return;
-}var j=(k.selectorText)?k.selectorText.replace(/^\w+/,function(i){return i.toLowerCase();}):null;if(!j||!b.test(j)){return;}Object.each(Element.Styles,function(l,i){if(!k.style[i]||Element.ShortStyles[i]){return;
-}l=String(k.style[i]);c[i]=((/^rgb/).test(l))?l.rgbToHex():l;});});});return Fx.CSS.Cache[a]=c;}});Fx.CSS.Cache={};Fx.CSS.Parsers={Color:{parse:function(a){if(a.match(/^#[0-9a-f]{3,6}$/i)){return a.hexToRgb(true);
-}return((a=a.match(/(\d+),\s*(\d+),\s*(\d+)/)))?[a[1],a[2],a[3]]:false;},compute:function(c,b,a){return c.map(function(e,d){return Math.round(Fx.compute(c[d],b[d],a));
-});},serve:function(a){return a.map(Number);}},Number:{parse:parseFloat,compute:Fx.compute,serve:function(b,a){return(a)?b+a:b;}},String:{parse:Function.from(false),compute:function(b,a){return a;
-},serve:function(a){return a;}}};Fx.Tween=new Class({Extends:Fx.CSS,initialize:function(b,a){this.element=this.subject=document.id(b);this.parent(a);},set:function(b,a){if(arguments.length==1){a=b;
-b=this.property||this.options.property;}this.render(this.element,b,a,this.options.unit);return this;},start:function(c,e,d){if(!this.check(c,e,d)){return this;
-}var b=Array.flatten(arguments);this.property=this.options.property||b.shift();var a=this.prepare(this.element,this.property,b);return this.parent(a.from,a.to);
-}});Element.Properties.tween={set:function(a){this.get("tween").cancel().setOptions(a);return this;},get:function(){var a=this.retrieve("tween");if(!a){a=new Fx.Tween(this,{link:"cancel"});
-this.store("tween",a);}return a;}};Element.implement({tween:function(a,c,b){this.get("tween").start(a,c,b);return this;},fade:function(c){var d=this.get("tween"),f,e,a;
-if(c==null){c="toggle";}switch(c){case"in":f="start";e=1;break;case"out":f="start";e=0;break;case"show":f="set";e=1;break;case"hide":f="set";e=0;break;
-case"toggle":var b=this.retrieve("fade:flag",this.getStyle("opacity")==1);f="start";e=b?0:1;this.store("fade:flag",!b);a=true;break;default:f="start";e=c;
-}if(!a){this.eliminate("fade:flag");}d[f]("opacity",e);if(f=="set"||e!=0){this.setStyle("visibility",e==0?"hidden":"visible");}else{d.chain(function(){this.element.setStyle("visibility","hidden");
-});}return this;},highlight:function(c,a){if(!a){a=this.retrieve("highlight:original",this.getStyle("background-color"));a=(a=="transparent")?"#fff":a;
-}var b=this.get("tween");b.start("background-color",c||"#ffff88",a).chain(function(){this.setStyle("background-color",this.retrieve("highlight:original"));
-b.callChain();}.bind(this));return this;}});Fx.Morph=new Class({Extends:Fx.CSS,initialize:function(b,a){this.element=this.subject=document.id(b);this.parent(a);
-},set:function(a){if(typeof a=="string"){a=this.search(a);}for(var b in a){this.render(this.element,b,a[b],this.options.unit);}return this;},compute:function(e,d,c){var a={};
-for(var b in e){a[b]=this.parent(e[b],d[b],c);}return a;},start:function(b){if(!this.check(b)){return this;}if(typeof b=="string"){b=this.search(b);}var e={},d={};
-for(var c in b){var a=this.prepare(this.element,c,b[c]);e[c]=a.from;d[c]=a.to;}return this.parent(e,d);}});Element.Properties.morph={set:function(a){this.get("morph").cancel().setOptions(a);
-return this;},get:function(){var a=this.retrieve("morph");if(!a){a=new Fx.Morph(this,{link:"cancel"});this.store("morph",a);}return a;}};Element.implement({morph:function(a){this.get("morph").start(a);
-return this;}});Fx.implement({getTransition:function(){var a=this.options.transition||Fx.Transitions.Sine.easeInOut;if(typeof a=="string"){var b=a.split(":");
-a=Fx.Transitions;a=a[b[0]]||a[b[0].capitalize()];if(b[1]){a=a["ease"+b[1].capitalize()+(b[2]?b[2].capitalize():"")];}}return a;}});Fx.Transition=function(c,b){b=Array.from(b);
-var a=function(d){return c(d,b);};return Object.append(a,{easeIn:a,easeOut:function(d){return 1-c(1-d,b);},easeInOut:function(d){return(d<=0.5?c(2*d,b):(2-c(2*(1-d),b)))/2;
-}});};Fx.Transitions={linear:function(a){return a;}};Fx.Transitions.extend=function(a){for(var b in a){Fx.Transitions[b]=new Fx.Transition(a[b]);}};Fx.Transitions.extend({Pow:function(b,a){return Math.pow(b,a&&a[0]||6);
-},Expo:function(a){return Math.pow(2,8*(a-1));},Circ:function(a){return 1-Math.sin(Math.acos(a));},Sine:function(a){return 1-Math.cos(a*Math.PI/2);},Back:function(b,a){a=a&&a[0]||1.618;
-return Math.pow(b,2)*((a+1)*b-a);},Bounce:function(f){var e;for(var d=0,c=1;1;d+=c,c/=2){if(f>=(7-4*d)/11){e=c*c-Math.pow((11-6*d-11*f)/4,2);break;}}return e;
-},Elastic:function(b,a){return Math.pow(2,10*--b)*Math.cos(20*b*Math.PI*(a&&a[0]||1)/3);}});["Quad","Cubic","Quart","Quint"].each(function(b,a){Fx.Transitions[b]=new Fx.Transition(function(c){return Math.pow(c,a+2);
-});});(function(){var d=function(){},a=("onprogress" in new Browser.Request);var c=this.Request=new Class({Implements:[Chain,Events,Options],options:{url:"",data:"",headers:{"X-Requested-With":"XMLHttpRequest",Accept:"text/javascript, text/html, application/xml, text/xml, */*"},async:true,format:false,method:"post",link:"ignore",isSuccess:null,emulation:true,urlEncoded:true,encoding:"utf-8",evalScripts:false,evalResponse:false,timeout:0,noCache:false},initialize:function(e){this.xhr=new Browser.Request();
-this.setOptions(e);this.headers=this.options.headers;},onStateChange:function(){var e=this.xhr;if(e.readyState!=4||!this.running){return;}this.running=false;
-this.status=0;Function.attempt(function(){var f=e.status;this.status=(f==1223)?204:f;}.bind(this));e.onreadystatechange=d;if(a){e.onprogress=e.onloadstart=d;
-}clearTimeout(this.timer);this.response={text:this.xhr.responseText||"",xml:this.xhr.responseXML};if(this.options.isSuccess.call(this,this.status)){this.success(this.response.text,this.response.xml);
-}else{this.failure();}},isSuccess:function(){var e=this.status;return(e>=200&&e<300);},isRunning:function(){return !!this.running;},processScripts:function(e){if(this.options.evalResponse||(/(ecma|java)script/).test(this.getHeader("Content-type"))){return Browser.exec(e);
-}return e.stripScripts(this.options.evalScripts);},success:function(f,e){this.onSuccess(this.processScripts(f),e);},onSuccess:function(){this.fireEvent("complete",arguments).fireEvent("success",arguments).callChain();
-},failure:function(){this.onFailure();},onFailure:function(){this.fireEvent("complete").fireEvent("failure",this.xhr);},loadstart:function(e){this.fireEvent("loadstart",[e,this.xhr]);
-},progress:function(e){this.fireEvent("progress",[e,this.xhr]);},timeout:function(){this.fireEvent("timeout",this.xhr);},setHeader:function(e,f){this.headers[e]=f;
-return this;},getHeader:function(e){return Function.attempt(function(){return this.xhr.getResponseHeader(e);}.bind(this));},check:function(){if(!this.running){return true;
-}switch(this.options.link){case"cancel":this.cancel();return true;case"chain":this.chain(this.caller.pass(arguments,this));return false;}return false;},send:function(o){if(!this.check(o)){return this;
-}this.options.isSuccess=this.options.isSuccess||this.isSuccess;this.running=true;var l=typeOf(o);if(l=="string"||l=="element"){o={data:o};}var h=this.options;
-o=Object.append({data:h.data,url:h.url,method:h.method},o);var j=o.data,f=String(o.url),e=o.method.toLowerCase();switch(typeOf(j)){case"element":j=document.id(j).toQueryString();
-break;case"object":case"hash":j=Object.toQueryString(j);}if(this.options.format){var m="format="+this.options.format;j=(j)?m+"&"+j:m;}if(this.options.emulation&&!["get","post"].contains(e)){var k="_method="+e;
-j=(j)?k+"&"+j:k;e="post";}if(this.options.urlEncoded&&["post","put"].contains(e)){var g=(this.options.encoding)?"; charset="+this.options.encoding:"";this.headers["Content-type"]="application/x-www-form-urlencoded"+g;
-}if(!f){f=document.location.pathname;}var i=f.lastIndexOf("/");if(i>-1&&(i=f.indexOf("#"))>-1){f=f.substr(0,i);}if(this.options.noCache){f+=(f.contains("?")?"&":"?")+String.uniqueID();
-}if(j&&e=="get"){f+=(f.contains("?")?"&":"?")+j;j=null;}var n=this.xhr;if(a){n.onloadstart=this.loadstart.bind(this);n.onprogress=this.progress.bind(this);
-}n.open(e.toUpperCase(),f,this.options.async,this.options.user,this.options.password);if(this.options.user&&"withCredentials" in n){n.withCredentials=true;
-}n.onreadystatechange=this.onStateChange.bind(this);Object.each(this.headers,function(q,p){try{n.setRequestHeader(p,q);}catch(r){this.fireEvent("exception",[p,q]);
-}},this);this.fireEvent("request");n.send(j);if(!this.options.async){this.onStateChange();}if(this.options.timeout){this.timer=this.timeout.delay(this.options.timeout,this);
-}return this;},cancel:function(){if(!this.running){return this;}this.running=false;var e=this.xhr;e.abort();clearTimeout(this.timer);e.onreadystatechange=d;
-if(a){e.onprogress=e.onloadstart=d;}this.xhr=new Browser.Request();this.fireEvent("cancel");return this;}});var b={};["get","post","put","delete","GET","POST","PUT","DELETE"].each(function(e){b[e]=function(g){var f={method:e};
-if(g!=null){f.data=g;}return this.send(f);};});c.implement(b);Element.Properties.send={set:function(e){var f=this.get("send").cancel();f.setOptions(e);
-return this;},get:function(){var e=this.retrieve("send");if(!e){e=new c({data:this,link:"cancel",method:this.get("method")||"post",url:this.get("action")});
-this.store("send",e);}return e;}};Element.implement({send:function(e){var f=this.get("send");f.send({data:this,url:e||f.options.url});return this;}});})();
-Request.HTML=new Class({Extends:Request,options:{update:false,append:false,evalScripts:true,filter:false,headers:{Accept:"text/html, application/xml, text/xml, */*"}},success:function(f){var e=this.options,c=this.response;
-c.html=f.stripScripts(function(h){c.javascript=h;});var d=c.html.match(/<body[^>]*>([\s\S]*?)<\/body>/i);if(d){c.html=d[1];}var b=new Element("div").set("html",c.html);
-c.tree=b.childNodes;c.elements=b.getElements(e.filter||"*");if(e.filter){c.tree=c.elements;}if(e.update){var g=document.id(e.update).empty();if(e.filter){g.adopt(c.elements);
-}else{g.set("html",c.html);}}else{if(e.append){var a=document.id(e.append);if(e.filter){c.elements.reverse().inject(a);}else{a.adopt(b.getChildren());}}}if(e.evalScripts){Browser.exec(c.javascript);
-}this.onSuccess(c.tree,c.elements,c.html,c.javascript);}});Element.Properties.load={set:function(a){var b=this.get("load").cancel();b.setOptions(a);return this;
-},get:function(){var a=this.retrieve("load");if(!a){a=new Request.HTML({data:this,link:"cancel",update:this,method:"get"});this.store("load",a);}return a;
-}};Element.implement({load:function(){this.get("load").send(Array.link(arguments,{data:Type.isObject,url:Type.isString}));return this;}});if(typeof JSON=="undefined"){this.JSON={};
-}(function(){var special={"\b":"\\b","\t":"\\t","\n":"\\n","\f":"\\f","\r":"\\r",'"':'\\"',"\\":"\\\\"};var escape=function(chr){return special[chr]||"\\u"+("0000"+chr.charCodeAt(0).toString(16)).slice(-4);
-};JSON.validate=function(string){string=string.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,"@").replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,"]").replace(/(?:^|:|,)(?:\s*\[)+/g,"");
-return(/^[\],:{}\s]*$/).test(string);};JSON.encode=JSON.stringify?function(obj){return JSON.stringify(obj);}:function(obj){if(obj&&obj.toJSON){obj=obj.toJSON();
-}switch(typeOf(obj)){case"string":return'"'+obj.replace(/[\x00-\x1f\\"]/g,escape)+'"';case"array":return"["+obj.map(JSON.encode).clean()+"]";case"object":case"hash":var string=[];
-Object.each(obj,function(value,key){var json=JSON.encode(value);if(json){string.push(JSON.encode(key)+":"+json);}});return"{"+string+"}";case"number":case"boolean":return""+obj;
-case"null":return"null";}return null;};JSON.decode=function(string,secure){if(!string||typeOf(string)!="string"){return null;}if(secure||JSON.secure){if(JSON.parse){return JSON.parse(string);
-}if(!JSON.validate(string)){throw new Error("JSON could not decode the input; security is enabled and the value is not secure.");}}return eval("("+string+")");
-};})();Request.JSON=new Class({Extends:Request,options:{secure:true},initialize:function(a){this.parent(a);Object.append(this.headers,{Accept:"application/json","X-Request":"JSON"});
-},success:function(c){var b;try{b=this.response.json=JSON.decode(c,this.options.secure);}catch(a){this.fireEvent("error",[c,a]);return;}if(b==null){this.onFailure();
-}else{this.onSuccess(b,c);}}});var Cookie=new Class({Implements:Options,options:{path:"/",domain:false,duration:false,secure:false,document:document,encode:true},initialize:function(b,a){this.key=b;
-this.setOptions(a);},write:function(b){if(this.options.encode){b=encodeURIComponent(b);}if(this.options.domain){b+="; domain="+this.options.domain;}if(this.options.path){b+="; path="+this.options.path;
-}if(this.options.duration){var a=new Date();a.setTime(a.getTime()+this.options.duration*24*60*60*1000);b+="; expires="+a.toGMTString();}if(this.options.secure){b+="; secure";
-}this.options.document.cookie=this.key+"="+b;return this;},read:function(){var a=this.options.document.cookie.match("(?:^|;)\\s*"+this.key.escapeRegExp()+"=([^;]*)");
-return(a)?decodeURIComponent(a[1]):null;},dispose:function(){new Cookie(this.key,Object.merge({},this.options,{duration:-1})).write("");return this;}});
-Cookie.write=function(b,c,a){return new Cookie(b,a).write(c);};Cookie.read=function(a){return new Cookie(a).read();};Cookie.dispose=function(b,a){return new Cookie(b,a).dispose();
-};(function(i,k){var l,f,e=[],c,b,d=k.createElement("div");var g=function(){clearTimeout(b);if(l){return;}Browser.loaded=l=true;k.removeListener("DOMContentLoaded",g).removeListener("readystatechange",a);
-k.fireEvent("domready");i.fireEvent("domready");};var a=function(){for(var m=e.length;m--;){if(e[m]()){g();return true;}}return false;};var j=function(){clearTimeout(b);
-if(!a()){b=setTimeout(j,10);}};k.addListener("DOMContentLoaded",g);var h=function(){try{d.doScroll();return true;}catch(m){}return false;};if(d.doScroll&&!h()){e.push(h);
-c=true;}if(k.readyState){e.push(function(){var m=k.readyState;return(m=="loaded"||m=="complete");});}if("onreadystatechange" in k){k.addListener("readystatechange",a);
-}else{c=true;}if(c){j();}Element.Events.domready={onAdd:function(m){if(l){m.call(this);}}};Element.Events.load={base:"load",onAdd:function(m){if(f&&this==i){m.call(this);
-}},condition:function(){if(this==i){g();delete Element.Events.load;}return true;}};i.addEvent("load",function(){f=true;});})(window,document);(function(){var Swiff=this.Swiff=new Class({Implements:Options,options:{id:null,height:1,width:1,container:null,properties:{},params:{quality:"high",allowScriptAccess:"always",wMode:"window",swLiveConnect:true},callBacks:{},vars:{}},toElement:function(){return this.object;
-},initialize:function(path,options){this.instance="Swiff_"+String.uniqueID();this.setOptions(options);options=this.options;var id=this.id=options.id||this.instance;
-var container=document.id(options.container);Swiff.CallBacks[this.instance]={};var params=options.params,vars=options.vars,callBacks=options.callBacks;
-var properties=Object.append({height:options.height,width:options.width},options.properties);var self=this;for(var callBack in callBacks){Swiff.CallBacks[this.instance][callBack]=(function(option){return function(){return option.apply(self.object,arguments);
-};})(callBacks[callBack]);vars[callBack]="Swiff.CallBacks."+this.instance+"."+callBack;}params.flashVars=Object.toQueryString(vars);if(Browser.ie){properties.classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000";
-params.movie=path;}else{properties.type="application/x-shockwave-flash";}properties.data=path;var build='<object id="'+id+'"';for(var property in properties){build+=" "+property+'="'+properties[property]+'"';
-}build+=">";for(var param in params){if(params[param]){build+='<param name="'+param+'" value="'+params[param]+'" />';}}build+="</object>";this.object=((container)?container.empty():new Element("div")).set("html",build).firstChild;
-},replaces:function(element){element=document.id(element,true);element.parentNode.replaceChild(this.toElement(),element);return this;},inject:function(element){document.id(element,true).appendChild(this.toElement());
-return this;},remote:function(){return Swiff.remote.apply(Swiff,[this.toElement()].append(arguments));}});Swiff.CallBacks={};Swiff.remote=function(obj,fn){var rs=obj.CallFunction('<invoke name="'+fn+'" returntype="javascript">'+__flash__argumentsToXML(arguments,2)+"</invoke>");
-return eval(rs);};})();
\ No newline at end of file
diff --git a/module/web/media/js/mootools-more-1.4.0.1.js b/module/web/media/js/mootools-more-1.4.0.1.js
deleted file mode 100644
index f3f8e4ee1..000000000
--- a/module/web/media/js/mootools-more-1.4.0.1.js
+++ /dev/null
@@ -1,216 +0,0 @@
-// MooTools: the javascript framework.
-// Load this file's selection again by visiting: http://mootools.net/more/c1cc18c2fff04bcc58921b4dff80a6f1 
-// Or build this file again with packager using: packager build More/Form.Request More/Fx.Reveal More/Sortables More/Request.Periodical More/Color
-/*
----
-copyrights:
-  - [MooTools](http://mootools.net)
-
-licenses:
-  - [MIT License](http://mootools.net/license.txt)
-...
-*/
-MooTools.More={version:"1.4.0.1",build:"a4244edf2aa97ac8a196fc96082dd35af1abab87"};Class.Mutators.Binds=function(a){if(!this.prototype.initialize){this.implement("initialize",function(){});
-}return Array.from(a).concat(this.prototype.Binds||[]);};Class.Mutators.initialize=function(a){return function(){Array.from(this.Binds).each(function(b){var c=this[b];
-if(c){this[b]=c.bind(this);}},this);return a.apply(this,arguments);};};Class.Occlude=new Class({occlude:function(c,b){b=document.id(b||this.element);var a=b.retrieve(c||this.property);
-if(a&&!this.occluded){return(this.occluded=a);}this.occluded=false;b.store(c||this.property,this);return this.occluded;}});Class.refactor=function(b,a){Object.each(a,function(e,d){var c=b.prototype[d];
-c=(c&&c.$origin)||c||function(){};b.implement(d,(typeof e=="function")?function(){var f=this.previous;this.previous=c;var g=e.apply(this,arguments);this.previous=f;
-return g;}:e);});return b;};(function(){var b=function(e,d){var f=[];Object.each(d,function(g){Object.each(g,function(h){e.each(function(i){f.push(i+"-"+h+(i=="border"?"-width":""));
-});});});return f;};var c=function(f,e){var d=0;Object.each(e,function(h,g){if(g.test(f)){d=d+h.toInt();}});return d;};var a=function(d){return !!(!d||d.offsetHeight||d.offsetWidth);
-};Element.implement({measure:function(h){if(a(this)){return h.call(this);}var g=this.getParent(),e=[];while(!a(g)&&g!=document.body){e.push(g.expose());
-g=g.getParent();}var f=this.expose(),d=h.call(this);f();e.each(function(i){i();});return d;},expose:function(){if(this.getStyle("display")!="none"){return function(){};
-}var d=this.style.cssText;this.setStyles({display:"block",position:"absolute",visibility:"hidden"});return function(){this.style.cssText=d;}.bind(this);
-},getDimensions:function(d){d=Object.merge({computeSize:false},d);var i={x:0,y:0};var h=function(j,e){return(e.computeSize)?j.getComputedSize(e):j.getSize();
-};var f=this.getParent("body");if(f&&this.getStyle("display")=="none"){i=this.measure(function(){return h(this,d);});}else{if(f){try{i=h(this,d);}catch(g){}}}return Object.append(i,(i.x||i.x===0)?{width:i.x,height:i.y}:{x:i.width,y:i.height});
-},getComputedSize:function(d){d=Object.merge({styles:["padding","border"],planes:{height:["top","bottom"],width:["left","right"]},mode:"both"},d);var g={},e={width:0,height:0},f;
-if(d.mode=="vertical"){delete e.width;delete d.planes.width;}else{if(d.mode=="horizontal"){delete e.height;delete d.planes.height;}}b(d.styles,d.planes).each(function(h){g[h]=this.getStyle(h).toInt();
-},this);Object.each(d.planes,function(i,h){var k=h.capitalize(),j=this.getStyle(h);if(j=="auto"&&!f){f=this.getDimensions();}j=g[h]=(j=="auto")?f[h]:j.toInt();
-e["total"+k]=j;i.each(function(m){var l=c(m,g);e["computed"+m.capitalize()]=l;e["total"+k]+=l;});},this);return Object.append(e,g);}});})();(function(b){var a=Element.Position={options:{relativeTo:document.body,position:{x:"center",y:"center"},offset:{x:0,y:0}},getOptions:function(d,c){c=Object.merge({},a.options,c);
-a.setPositionOption(c);a.setEdgeOption(c);a.setOffsetOption(d,c);a.setDimensionsOption(d,c);return c;},setPositionOption:function(c){c.position=a.getCoordinateFromValue(c.position);
-},setEdgeOption:function(d){var c=a.getCoordinateFromValue(d.edge);d.edge=c?c:(d.position.x=="center"&&d.position.y=="center")?{x:"center",y:"center"}:{x:"left",y:"top"};
-},setOffsetOption:function(f,d){var c={x:0,y:0},g=f.measure(function(){return document.id(this.getOffsetParent());}),e=g.getScroll();if(!g||g==f.getDocument().body){return;
-}c=g.measure(function(){var i=this.getPosition();if(this.getStyle("position")=="fixed"){var h=window.getScroll();i.x+=h.x;i.y+=h.y;}return i;});d.offset={parentPositioned:g!=document.id(d.relativeTo),x:d.offset.x-c.x+e.x,y:d.offset.y-c.y+e.y};
-},setDimensionsOption:function(d,c){c.dimensions=d.getDimensions({computeSize:true,styles:["padding","border","margin"]});},getPosition:function(e,d){var c={};
-d=a.getOptions(e,d);var f=document.id(d.relativeTo)||document.body;a.setPositionCoordinates(d,c,f);if(d.edge){a.toEdge(c,d);}var g=d.offset;c.left=((c.x>=0||g.parentPositioned||d.allowNegative)?c.x:0).toInt();
-c.top=((c.y>=0||g.parentPositioned||d.allowNegative)?c.y:0).toInt();a.toMinMax(c,d);if(d.relFixedPosition||f.getStyle("position")=="fixed"){a.toRelFixedPosition(f,c);
-}if(d.ignoreScroll){a.toIgnoreScroll(f,c);}if(d.ignoreMargins){a.toIgnoreMargins(c,d);}c.left=Math.ceil(c.left);c.top=Math.ceil(c.top);delete c.x;delete c.y;
-return c;},setPositionCoordinates:function(k,g,d){var f=k.offset.y,h=k.offset.x,e=(d==document.body)?window.getScroll():d.getPosition(),j=e.y,c=e.x,i=window.getSize();
-switch(k.position.x){case"left":g.x=c+h;break;case"right":g.x=c+h+d.offsetWidth;break;default:g.x=c+((d==document.body?i.x:d.offsetWidth)/2)+h;break;}switch(k.position.y){case"top":g.y=j+f;
-break;case"bottom":g.y=j+f+d.offsetHeight;break;default:g.y=j+((d==document.body?i.y:d.offsetHeight)/2)+f;break;}},toMinMax:function(c,d){var f={left:"x",top:"y"},e;
-["minimum","maximum"].each(function(g){["left","top"].each(function(h){e=d[g]?d[g][f[h]]:null;if(e!=null&&((g=="minimum")?c[h]<e:c[h]>e)){c[h]=e;}});});
-},toRelFixedPosition:function(e,c){var d=window.getScroll();c.top+=d.y;c.left+=d.x;},toIgnoreScroll:function(e,d){var c=e.getScroll();d.top-=c.y;d.left-=c.x;
-},toIgnoreMargins:function(c,d){c.left+=d.edge.x=="right"?d.dimensions["margin-right"]:(d.edge.x!="center"?-d.dimensions["margin-left"]:-d.dimensions["margin-left"]+((d.dimensions["margin-right"]+d.dimensions["margin-left"])/2));
-c.top+=d.edge.y=="bottom"?d.dimensions["margin-bottom"]:(d.edge.y!="center"?-d.dimensions["margin-top"]:-d.dimensions["margin-top"]+((d.dimensions["margin-bottom"]+d.dimensions["margin-top"])/2));
-},toEdge:function(c,d){var e={},g=d.dimensions,f=d.edge;switch(f.x){case"left":e.x=0;break;case"right":e.x=-g.x-g.computedRight-g.computedLeft;break;default:e.x=-(Math.round(g.totalWidth/2));
-break;}switch(f.y){case"top":e.y=0;break;case"bottom":e.y=-g.y-g.computedTop-g.computedBottom;break;default:e.y=-(Math.round(g.totalHeight/2));break;}c.x+=e.x;
-c.y+=e.y;},getCoordinateFromValue:function(c){if(typeOf(c)!="string"){return c;}c=c.toLowerCase();return{x:c.test("left")?"left":(c.test("right")?"right":"center"),y:c.test(/upper|top/)?"top":(c.test("bottom")?"bottom":"center")};
-}};Element.implement({position:function(d){if(d&&(d.x!=null||d.y!=null)){return(b?b.apply(this,arguments):this);}var c=this.setStyle("position","absolute").calculatePosition(d);
-return(d&&d.returnPos)?c:this.setStyles(c);},calculatePosition:function(c){return a.getPosition(this,c);}});})(Element.prototype.position);var IframeShim=new Class({Implements:[Options,Events,Class.Occlude],options:{className:"iframeShim",src:'javascript:false;document.write("");',display:false,zIndex:null,margin:0,offset:{x:0,y:0},browsers:(Browser.ie6||(Browser.firefox&&Browser.version<3&&Browser.Platform.mac))},property:"IframeShim",initialize:function(b,a){this.element=document.id(b);
-if(this.occlude()){return this.occluded;}this.setOptions(a);this.makeShim();return this;},makeShim:function(){if(this.options.browsers){var c=this.element.getStyle("zIndex").toInt();
-if(!c){c=1;var b=this.element.getStyle("position");if(b=="static"||!b){this.element.setStyle("position","relative");}this.element.setStyle("zIndex",c);
-}c=((this.options.zIndex!=null||this.options.zIndex===0)&&c>this.options.zIndex)?this.options.zIndex:c-1;if(c<0){c=1;}this.shim=new Element("iframe",{src:this.options.src,scrolling:"no",frameborder:0,styles:{zIndex:c,position:"absolute",border:"none",filter:"progid:DXImageTransform.Microsoft.Alpha(style=0,opacity=0)"},"class":this.options.className}).store("IframeShim",this);
-var a=(function(){this.shim.inject(this.element,"after");this[this.options.display?"show":"hide"]();this.fireEvent("inject");}).bind(this);if(!IframeShim.ready){window.addEvent("load",a);
-}else{a();}}else{this.position=this.hide=this.show=this.dispose=Function.from(this);}},position:function(){if(!IframeShim.ready||!this.shim){return this;
-}var a=this.element.measure(function(){return this.getSize();});if(this.options.margin!=undefined){a.x=a.x-(this.options.margin*2);a.y=a.y-(this.options.margin*2);
-this.options.offset.x+=this.options.margin;this.options.offset.y+=this.options.margin;}this.shim.set({width:a.x,height:a.y}).position({relativeTo:this.element,offset:this.options.offset});
-return this;},hide:function(){if(this.shim){this.shim.setStyle("display","none");}return this;},show:function(){if(this.shim){this.shim.setStyle("display","block");
-}return this.position();},dispose:function(){if(this.shim){this.shim.dispose();}return this;},destroy:function(){if(this.shim){this.shim.destroy();}return this;
-}});window.addEvent("load",function(){IframeShim.ready=true;});var Mask=new Class({Implements:[Options,Events],Binds:["position"],options:{style:{},"class":"mask",maskMargins:false,useIframeShim:true,iframeShimOptions:{}},initialize:function(b,a){this.target=document.id(b)||document.id(document.body);
-this.target.store("mask",this);this.setOptions(a);this.render();this.inject();},render:function(){this.element=new Element("div",{"class":this.options["class"],id:this.options.id||"mask-"+String.uniqueID(),styles:Object.merge({},this.options.style,{display:"none"}),events:{click:function(a){this.fireEvent("click",a);
-if(this.options.hideOnClick){this.hide();}}.bind(this)}});this.hidden=true;},toElement:function(){return this.element;},inject:function(b,a){a=a||(this.options.inject?this.options.inject.where:"")||this.target==document.body?"inside":"after";
-b=b||(this.options.inject&&this.options.inject.target)||this.target;this.element.inject(b,a);if(this.options.useIframeShim){this.shim=new IframeShim(this.element,this.options.iframeShimOptions);
-this.addEvents({show:this.shim.show.bind(this.shim),hide:this.shim.hide.bind(this.shim),destroy:this.shim.destroy.bind(this.shim)});}},position:function(){this.resize(this.options.width,this.options.height);
-this.element.position({relativeTo:this.target,position:"topLeft",ignoreMargins:!this.options.maskMargins,ignoreScroll:this.target==document.body});return this;
-},resize:function(a,e){var b={styles:["padding","border"]};if(this.options.maskMargins){b.styles.push("margin");}var d=this.target.getComputedSize(b);if(this.target==document.body){this.element.setStyles({width:0,height:0});
-var c=window.getScrollSize();if(d.totalHeight<c.y){d.totalHeight=c.y;}if(d.totalWidth<c.x){d.totalWidth=c.x;}}this.element.setStyles({width:Array.pick([a,d.totalWidth,d.x]),height:Array.pick([e,d.totalHeight,d.y])});
-return this;},show:function(){if(!this.hidden){return this;}window.addEvent("resize",this.position);this.position();this.showMask.apply(this,arguments);
-return this;},showMask:function(){this.element.setStyle("display","block");this.hidden=false;this.fireEvent("show");},hide:function(){if(this.hidden){return this;
-}window.removeEvent("resize",this.position);this.hideMask.apply(this,arguments);if(this.options.destroyOnHide){return this.destroy();}return this;},hideMask:function(){this.element.setStyle("display","none");
-this.hidden=true;this.fireEvent("hide");},toggle:function(){this[this.hidden?"show":"hide"]();},destroy:function(){this.hide();this.element.destroy();this.fireEvent("destroy");
-this.target.eliminate("mask");}});Element.Properties.mask={set:function(b){var a=this.retrieve("mask");if(a){a.destroy();}return this.eliminate("mask").store("mask:options",b);
-},get:function(){var a=this.retrieve("mask");if(!a){a=new Mask(this,this.retrieve("mask:options"));this.store("mask",a);}return a;}};Element.implement({mask:function(a){if(a){this.set("mask",a);
-}this.get("mask").show();return this;},unmask:function(){this.get("mask").hide();return this;}});var Spinner=new Class({Extends:Mask,Implements:Chain,options:{"class":"spinner",containerPosition:{},content:{"class":"spinner-content"},messageContainer:{"class":"spinner-msg"},img:{"class":"spinner-img"},fxOptions:{link:"chain"}},initialize:function(c,a){this.target=document.id(c)||document.id(document.body);
-this.target.store("spinner",this);this.setOptions(a);this.render();this.inject();var b=function(){this.active=false;}.bind(this);this.addEvents({hide:b,show:b});
-},render:function(){this.parent();this.element.set("id",this.options.id||"spinner-"+String.uniqueID());this.content=document.id(this.options.content)||new Element("div",this.options.content);
-this.content.inject(this.element);if(this.options.message){this.msg=document.id(this.options.message)||new Element("p",this.options.messageContainer).appendText(this.options.message);
-this.msg.inject(this.content);}if(this.options.img){this.img=document.id(this.options.img)||new Element("div",this.options.img);this.img.inject(this.content);
-}this.element.set("tween",this.options.fxOptions);},show:function(a){if(this.active){return this.chain(this.show.bind(this));}if(!this.hidden){this.callChain.delay(20,this);
-return this;}this.active=true;return this.parent(a);},showMask:function(a){var b=function(){this.content.position(Object.merge({relativeTo:this.element},this.options.containerPosition));
-}.bind(this);if(a){this.parent();b();}else{if(!this.options.style.opacity){this.options.style.opacity=this.element.getStyle("opacity").toFloat();}this.element.setStyles({display:"block",opacity:0}).tween("opacity",this.options.style.opacity);
-b();this.hidden=false;this.fireEvent("show");this.callChain();}},hide:function(a){if(this.active){return this.chain(this.hide.bind(this));}if(this.hidden){this.callChain.delay(20,this);
-return this;}this.active=true;return this.parent(a);},hideMask:function(a){if(a){return this.parent();}this.element.tween("opacity",0).get("tween").chain(function(){this.element.setStyle("display","none");
-this.hidden=true;this.fireEvent("hide");this.callChain();}.bind(this));},destroy:function(){this.content.destroy();this.parent();this.target.eliminate("spinner");
-}});Request=Class.refactor(Request,{options:{useSpinner:false,spinnerOptions:{},spinnerTarget:false},initialize:function(a){this._send=this.send;this.send=function(b){var c=this.getSpinner();
-if(c){c.chain(this._send.pass(b,this)).show();}else{this._send(b);}return this;};this.previous(a);},getSpinner:function(){if(!this.spinner){var b=document.id(this.options.spinnerTarget)||document.id(this.options.update);
-if(this.options.useSpinner&&b){b.set("spinner",this.options.spinnerOptions);var a=this.spinner=b.get("spinner");["complete","exception","cancel"].each(function(c){this.addEvent(c,a.hide.bind(a));
-},this);}}return this.spinner;}});Element.Properties.spinner={set:function(a){var b=this.retrieve("spinner");if(b){b.destroy();}return this.eliminate("spinner").store("spinner:options",a);
-},get:function(){var a=this.retrieve("spinner");if(!a){a=new Spinner(this,this.retrieve("spinner:options"));this.store("spinner",a);}return a;}};Element.implement({spin:function(a){if(a){this.set("spinner",a);
-}this.get("spinner").show();return this;},unspin:function(){this.get("spinner").hide();return this;}});String.implement({parseQueryString:function(d,a){if(d==null){d=true;
-}if(a==null){a=true;}var c=this.split(/[&;]/),b={};if(!c.length){return b;}c.each(function(i){var e=i.indexOf("=")+1,g=e?i.substr(e):"",f=e?i.substr(0,e-1).match(/([^\]\[]+|(\B)(?=\]))/g):[i],h=b;
-if(!f){return;}if(a){g=decodeURIComponent(g);}f.each(function(k,j){if(d){k=decodeURIComponent(k);}var l=h[k];if(j<f.length-1){h=h[k]=l||{};}else{if(typeOf(l)=="array"){l.push(g);
-}else{h[k]=l!=null?[l,g]:g;}}});});return b;},cleanQueryString:function(a){return this.split("&").filter(function(e){var b=e.indexOf("="),c=b<0?"":e.substr(0,b),d=e.substr(b+1);
-return a?a.call(null,c,d):(d||d===0);}).join("&");}});(function(){Events.Pseudos=function(h,e,f){var d="_monitorEvents:";var c=function(i){return{store:i.store?function(j,k){i.store(d+j,k);
-}:function(j,k){(i._monitorEvents||(i._monitorEvents={}))[j]=k;},retrieve:i.retrieve?function(j,k){return i.retrieve(d+j,k);}:function(j,k){if(!i._monitorEvents){return k;
-}return i._monitorEvents[j]||k;}};};var g=function(k){if(k.indexOf(":")==-1||!h){return null;}var j=Slick.parse(k).expressions[0][0],p=j.pseudos,i=p.length,o=[];
-while(i--){var n=p[i].key,m=h[n];if(m!=null){o.push({event:j.tag,value:p[i].value,pseudo:n,original:k,listener:m});}}return o.length?o:null;};return{addEvent:function(m,p,j){var n=g(m);
-if(!n){return e.call(this,m,p,j);}var k=c(this),r=k.retrieve(m,[]),i=n[0].event,l=Array.slice(arguments,2),o=p,q=this;n.each(function(s){var t=s.listener,u=o;
-if(t==false){i+=":"+s.pseudo+"("+s.value+")";}else{o=function(){t.call(q,s,u,arguments,o);};}});r.include({type:i,event:p,monitor:o});k.store(m,r);if(m!=i){e.apply(this,[m,p].concat(l));
-}return e.apply(this,[i,o].concat(l));},removeEvent:function(m,l){var k=g(m);if(!k){return f.call(this,m,l);}var n=c(this),j=n.retrieve(m);if(!j){return this;
-}var i=Array.slice(arguments,2);f.apply(this,[m,l].concat(i));j.each(function(o,p){if(!l||o.event==l){f.apply(this,[o.type,o.monitor].concat(i));}delete j[p];
-},this);n.store(m,j);return this;}};};var b={once:function(e,f,d,c){f.apply(this,d);this.removeEvent(e.event,c).removeEvent(e.original,f);},throttle:function(d,e,c){if(!e._throttled){e.apply(this,c);
-e._throttled=setTimeout(function(){e._throttled=false;},d.value||250);}},pause:function(d,e,c){clearTimeout(e._pause);e._pause=e.delay(d.value||250,this,c);
-}};Events.definePseudo=function(c,d){b[c]=d;return this;};Events.lookupPseudo=function(c){return b[c];};var a=Events.prototype;Events.implement(Events.Pseudos(b,a.addEvent,a.removeEvent));
-["Request","Fx"].each(function(c){if(this[c]){this[c].implement(Events.prototype);}});})();(function(){var d={relay:false},c=["once","throttle","pause"],b=c.length;
-while(b--){d[c[b]]=Events.lookupPseudo(c[b]);}DOMEvent.definePseudo=function(e,f){d[e]=f;return this;};var a=Element.prototype;[Element,Window,Document].invoke("implement",Events.Pseudos(d,a.addEvent,a.removeEvent));
-})();if(!window.Form){window.Form={};}(function(){Form.Request=new Class({Binds:["onSubmit","onFormValidate"],Implements:[Options,Events,Class.Occlude],options:{requestOptions:{evalScripts:true,useSpinner:true,emulation:false,link:"ignore"},sendButtonClicked:true,extraData:{},resetForm:true},property:"form.request",initialize:function(b,c,a){this.element=document.id(b);
-if(this.occlude()){return this.occluded;}this.setOptions(a).setTarget(c).attach();},setTarget:function(a){this.target=document.id(a);if(!this.request){this.makeRequest();
-}else{this.request.setOptions({update:this.target});}return this;},toElement:function(){return this.element;},makeRequest:function(){var a=this;this.request=new Request.HTML(Object.merge({update:this.target,emulation:false,spinnerTarget:this.element,method:this.element.get("method")||"post"},this.options.requestOptions)).addEvents({success:function(c,e,d,b){["complete","success"].each(function(f){a.fireEvent(f,[a.target,c,e,d,b]);
-});},failure:function(){a.fireEvent("complete",arguments).fireEvent("failure",arguments);},exception:function(){a.fireEvent("failure",arguments);}});return this.attachReset();
-},attachReset:function(){if(!this.options.resetForm){return this;}this.request.addEvent("success",function(){Function.attempt(function(){this.element.reset();
-}.bind(this));if(window.OverText){OverText.update();}}.bind(this));return this;},attach:function(a){var c=(a!=false)?"addEvent":"removeEvent";this.element[c]("click:relay(button, input[type=submit])",this.saveClickedButton.bind(this));
-var b=this.element.retrieve("validator");if(b){b[c]("onFormValidate",this.onFormValidate);}else{this.element[c]("submit",this.onSubmit);}return this;},detach:function(){return this.attach(false);
-},enable:function(){return this.attach();},disable:function(){return this.detach();},onFormValidate:function(c,b,a){if(!a){return;}var d=this.element.retrieve("validator");
-if(c||(d&&!d.options.stopOnFailure)){a.stop();this.send();}},onSubmit:function(a){var b=this.element.retrieve("validator");if(b){this.element.removeEvent("submit",this.onSubmit);
-b.addEvent("onFormValidate",this.onFormValidate);this.element.validate();return;}if(a){a.stop();}this.send();},saveClickedButton:function(b,c){var a=c.get("name");
-if(!a||!this.options.sendButtonClicked){return;}this.options.extraData[a]=c.get("value")||true;this.clickedCleaner=function(){delete this.options.extraData[a];
-this.clickedCleaner=function(){};}.bind(this);},clickedCleaner:function(){},send:function(){var b=this.element.toQueryString().trim(),a=Object.toQueryString(this.options.extraData);
-if(b){b+="&"+a;}else{b=a;}this.fireEvent("send",[this.element,b.parseQueryString()]);this.request.send({data:b,url:this.options.requestOptions.url||this.element.get("action")});
-this.clickedCleaner();return this;}});Element.implement("formUpdate",function(c,b){var a=this.retrieve("form.request");if(!a){a=new Form.Request(this,c,b);
-}else{if(c){a.setTarget(c);}if(b){a.setOptions(b).makeRequest();}}a.send();return this;});})();Element.implement({isDisplayed:function(){return this.getStyle("display")!="none";
-},isVisible:function(){var a=this.offsetWidth,b=this.offsetHeight;return(a==0&&b==0)?false:(a>0&&b>0)?true:this.style.display!="none";},toggle:function(){return this[this.isDisplayed()?"hide":"show"]();
-},hide:function(){var b;try{b=this.getStyle("display");}catch(a){}if(b=="none"){return this;}return this.store("element:_originalDisplay",b||"").setStyle("display","none");
-},show:function(a){if(!a&&this.isDisplayed()){return this;}a=a||this.retrieve("element:_originalDisplay")||"block";return this.setStyle("display",(a=="none")?"block":a);
-},swapClass:function(a,b){return this.removeClass(a).addClass(b);}});Document.implement({clearSelection:function(){if(window.getSelection){var a=window.getSelection();
-if(a&&a.removeAllRanges){a.removeAllRanges();}}else{if(document.selection&&document.selection.empty){try{document.selection.empty();}catch(b){}}}}});(function(){var a=function(d){var b=d.options.hideInputs;
-if(window.OverText){var c=[null];OverText.each(function(e){c.include("."+e.options.labelClass);});if(c){b+=c.join(", ");}}return(b)?d.element.getElements(b):null;
-};Fx.Reveal=new Class({Extends:Fx.Morph,options:{link:"cancel",styles:["padding","border","margin"],transitionOpacity:!Browser.ie6,mode:"vertical",display:function(){return this.element.get("tag")!="tr"?"block":"table-row";
-},opacity:1,hideInputs:Browser.ie?"select, input, textarea, object, embed":null},dissolve:function(){if(!this.hiding&&!this.showing){if(this.element.getStyle("display")!="none"){this.hiding=true;
-this.showing=false;this.hidden=true;this.cssText=this.element.style.cssText;var d=this.element.getComputedSize({styles:this.options.styles,mode:this.options.mode});
-if(this.options.transitionOpacity){d.opacity=this.options.opacity;}var c={};Object.each(d,function(f,e){c[e]=[f,0];});this.element.setStyles({display:Function.from(this.options.display).call(this),overflow:"hidden"});
-var b=a(this);if(b){b.setStyle("visibility","hidden");}this.$chain.unshift(function(){if(this.hidden){this.hiding=false;this.element.style.cssText=this.cssText;
-this.element.setStyle("display","none");if(b){b.setStyle("visibility","visible");}}this.fireEvent("hide",this.element);this.callChain();}.bind(this));this.start(c);
-}else{this.callChain.delay(10,this);this.fireEvent("complete",this.element);this.fireEvent("hide",this.element);}}else{if(this.options.link=="chain"){this.chain(this.dissolve.bind(this));
-}else{if(this.options.link=="cancel"&&!this.hiding){this.cancel();this.dissolve();}}}return this;},reveal:function(){if(!this.showing&&!this.hiding){if(this.element.getStyle("display")=="none"){this.hiding=false;
-this.showing=true;this.hidden=false;this.cssText=this.element.style.cssText;var d;this.element.measure(function(){d=this.element.getComputedSize({styles:this.options.styles,mode:this.options.mode});
-}.bind(this));if(this.options.heightOverride!=null){d.height=this.options.heightOverride.toInt();}if(this.options.widthOverride!=null){d.width=this.options.widthOverride.toInt();
-}if(this.options.transitionOpacity){this.element.setStyle("opacity",0);d.opacity=this.options.opacity;}var c={height:0,display:Function.from(this.options.display).call(this)};
-Object.each(d,function(f,e){c[e]=0;});c.overflow="hidden";this.element.setStyles(c);var b=a(this);if(b){b.setStyle("visibility","hidden");}this.$chain.unshift(function(){this.element.style.cssText=this.cssText;
-this.element.setStyle("display",Function.from(this.options.display).call(this));if(!this.hidden){this.showing=false;}if(b){b.setStyle("visibility","visible");
-}this.callChain();this.fireEvent("show",this.element);}.bind(this));this.start(d);}else{this.callChain();this.fireEvent("complete",this.element);this.fireEvent("show",this.element);
-}}else{if(this.options.link=="chain"){this.chain(this.reveal.bind(this));}else{if(this.options.link=="cancel"&&!this.showing){this.cancel();this.reveal();
-}}}return this;},toggle:function(){if(this.element.getStyle("display")=="none"){this.reveal();}else{this.dissolve();}return this;},cancel:function(){this.parent.apply(this,arguments);
-if(this.cssText!=null){this.element.style.cssText=this.cssText;}this.hiding=false;this.showing=false;return this;}});Element.Properties.reveal={set:function(b){this.get("reveal").cancel().setOptions(b);
-return this;},get:function(){var b=this.retrieve("reveal");if(!b){b=new Fx.Reveal(this);this.store("reveal",b);}return b;}};Element.Properties.dissolve=Element.Properties.reveal;
-Element.implement({reveal:function(b){this.get("reveal").setOptions(b).reveal();return this;},dissolve:function(b){this.get("reveal").setOptions(b).dissolve();
-return this;},nix:function(b){var c=Array.link(arguments,{destroy:Type.isBoolean,options:Type.isObject});this.get("reveal").setOptions(b).dissolve().chain(function(){this[c.destroy?"destroy":"dispose"]();
-}.bind(this));return this;},wink:function(){var c=Array.link(arguments,{duration:Type.isNumber,options:Type.isObject});var b=this.get("reveal").setOptions(c.options);
-b.reveal().chain(function(){(function(){b.dissolve();}).delay(c.duration||2000);});}});})();var Drag=new Class({Implements:[Events,Options],options:{snap:6,unit:"px",grid:false,style:true,limit:false,handle:false,invert:false,preventDefault:false,stopPropagation:false,modifiers:{x:"left",y:"top"}},initialize:function(){var b=Array.link(arguments,{options:Type.isObject,element:function(c){return c!=null;
-}});this.element=document.id(b.element);this.document=this.element.getDocument();this.setOptions(b.options||{});var a=typeOf(this.options.handle);this.handles=((a=="array"||a=="collection")?$$(this.options.handle):document.id(this.options.handle))||this.element;
-this.mouse={now:{},pos:{}};this.value={start:{},now:{}};this.selection=(Browser.ie)?"selectstart":"mousedown";if(Browser.ie&&!Drag.ondragstartFixed){document.ondragstart=Function.from(false);
-Drag.ondragstartFixed=true;}this.bound={start:this.start.bind(this),check:this.check.bind(this),drag:this.drag.bind(this),stop:this.stop.bind(this),cancel:this.cancel.bind(this),eventStop:Function.from(false)};
-this.attach();},attach:function(){this.handles.addEvent("mousedown",this.bound.start);return this;},detach:function(){this.handles.removeEvent("mousedown",this.bound.start);
-return this;},start:function(a){var j=this.options;if(a.rightClick){return;}if(j.preventDefault){a.preventDefault();}if(j.stopPropagation){a.stopPropagation();
-}this.mouse.start=a.page;this.fireEvent("beforeStart",this.element);var c=j.limit;this.limit={x:[],y:[]};var e,g;for(e in j.modifiers){if(!j.modifiers[e]){continue;
-}var b=this.element.getStyle(j.modifiers[e]);if(b&&!b.match(/px$/)){if(!g){g=this.element.getCoordinates(this.element.getOffsetParent());}b=g[j.modifiers[e]];
-}if(j.style){this.value.now[e]=(b||0).toInt();}else{this.value.now[e]=this.element[j.modifiers[e]];}if(j.invert){this.value.now[e]*=-1;}this.mouse.pos[e]=a.page[e]-this.value.now[e];
-if(c&&c[e]){var d=2;while(d--){var f=c[e][d];if(f||f===0){this.limit[e][d]=(typeof f=="function")?f():f;}}}}if(typeOf(this.options.grid)=="number"){this.options.grid={x:this.options.grid,y:this.options.grid};
-}var h={mousemove:this.bound.check,mouseup:this.bound.cancel};h[this.selection]=this.bound.eventStop;this.document.addEvents(h);},check:function(a){if(this.options.preventDefault){a.preventDefault();
-}var b=Math.round(Math.sqrt(Math.pow(a.page.x-this.mouse.start.x,2)+Math.pow(a.page.y-this.mouse.start.y,2)));if(b>this.options.snap){this.cancel();this.document.addEvents({mousemove:this.bound.drag,mouseup:this.bound.stop});
-this.fireEvent("start",[this.element,a]).fireEvent("snap",this.element);}},drag:function(b){var a=this.options;if(a.preventDefault){b.preventDefault();
-}this.mouse.now=b.page;for(var c in a.modifiers){if(!a.modifiers[c]){continue;}this.value.now[c]=this.mouse.now[c]-this.mouse.pos[c];if(a.invert){this.value.now[c]*=-1;
-}if(a.limit&&this.limit[c]){if((this.limit[c][1]||this.limit[c][1]===0)&&(this.value.now[c]>this.limit[c][1])){this.value.now[c]=this.limit[c][1];}else{if((this.limit[c][0]||this.limit[c][0]===0)&&(this.value.now[c]<this.limit[c][0])){this.value.now[c]=this.limit[c][0];
-}}}if(a.grid[c]){this.value.now[c]-=((this.value.now[c]-(this.limit[c][0]||0))%a.grid[c]);}if(a.style){this.element.setStyle(a.modifiers[c],this.value.now[c]+a.unit);
-}else{this.element[a.modifiers[c]]=this.value.now[c];}}this.fireEvent("drag",[this.element,b]);},cancel:function(a){this.document.removeEvents({mousemove:this.bound.check,mouseup:this.bound.cancel});
-if(a){this.document.removeEvent(this.selection,this.bound.eventStop);this.fireEvent("cancel",this.element);}},stop:function(b){var a={mousemove:this.bound.drag,mouseup:this.bound.stop};
-a[this.selection]=this.bound.eventStop;this.document.removeEvents(a);if(b){this.fireEvent("complete",[this.element,b]);}}});Element.implement({makeResizable:function(a){var b=new Drag(this,Object.merge({modifiers:{x:"width",y:"height"}},a));
-this.store("resizer",b);return b.addEvent("drag",function(){this.fireEvent("resize",b);}.bind(this));}});Drag.Move=new Class({Extends:Drag,options:{droppables:[],container:false,precalculate:false,includeMargins:true,checkDroppables:true},initialize:function(b,a){this.parent(b,a);
-b=this.element;this.droppables=$$(this.options.droppables);this.container=document.id(this.options.container);if(this.container&&typeOf(this.container)!="element"){this.container=document.id(this.container.getDocument().body);
-}if(this.options.style){if(this.options.modifiers.x=="left"&&this.options.modifiers.y=="top"){var c=b.getOffsetParent(),d=b.getStyles("left","top");if(c&&(d.left=="auto"||d.top=="auto")){b.setPosition(b.getPosition(c));
-}}if(b.getStyle("position")=="static"){b.setStyle("position","absolute");}}this.addEvent("start",this.checkDroppables,true);this.overed=null;},start:function(a){if(this.container){this.options.limit=this.calculateLimit();
-}if(this.options.precalculate){this.positions=this.droppables.map(function(b){return b.getCoordinates();});}this.parent(a);},calculateLimit:function(){var j=this.element,e=this.container,d=document.id(j.getOffsetParent())||document.body,h=e.getCoordinates(d),c={},b={},k={},g={},m={};
-["top","right","bottom","left"].each(function(q){c[q]=j.getStyle("margin-"+q).toInt();b[q]=j.getStyle("border-"+q).toInt();k[q]=e.getStyle("margin-"+q).toInt();
-g[q]=e.getStyle("border-"+q).toInt();m[q]=d.getStyle("padding-"+q).toInt();},this);var f=j.offsetWidth+c.left+c.right,p=j.offsetHeight+c.top+c.bottom,i=0,l=0,o=h.right-g.right-f,a=h.bottom-g.bottom-p;
-if(this.options.includeMargins){i+=c.left;l+=c.top;}else{o+=c.right;a+=c.bottom;}if(j.getStyle("position")=="relative"){var n=j.getCoordinates(d);n.left-=j.getStyle("left").toInt();
-n.top-=j.getStyle("top").toInt();i-=n.left;l-=n.top;if(e.getStyle("position")!="relative"){i+=g.left;l+=g.top;}o+=c.left-n.left;a+=c.top-n.top;if(e!=d){i+=k.left+m.left;
-l+=((Browser.ie6||Browser.ie7)?0:k.top)+m.top;}}else{i-=c.left;l-=c.top;if(e!=d){i+=h.left+g.left;l+=h.top+g.top;}}return{x:[i,o],y:[l,a]};},getDroppableCoordinates:function(c){var b=c.getCoordinates();
-if(c.getStyle("position")=="fixed"){var a=window.getScroll();b.left+=a.x;b.right+=a.x;b.top+=a.y;b.bottom+=a.y;}return b;},checkDroppables:function(){var a=this.droppables.filter(function(d,c){d=this.positions?this.positions[c]:this.getDroppableCoordinates(d);
-var b=this.mouse.now;return(b.x>d.left&&b.x<d.right&&b.y<d.bottom&&b.y>d.top);},this).getLast();if(this.overed!=a){if(this.overed){this.fireEvent("leave",[this.element,this.overed]);
-}if(a){this.fireEvent("enter",[this.element,a]);}this.overed=a;}},drag:function(a){this.parent(a);if(this.options.checkDroppables&&this.droppables.length){this.checkDroppables();
-}},stop:function(a){this.checkDroppables();this.fireEvent("drop",[this.element,this.overed,a]);this.overed=null;return this.parent(a);}});Element.implement({makeDraggable:function(a){var b=new Drag.Move(this,a);
-this.store("dragger",b);return b;}});var Sortables=new Class({Implements:[Events,Options],options:{opacity:1,clone:false,revert:false,handle:false,dragOptions:{}},initialize:function(a,b){this.setOptions(b);
-this.elements=[];this.lists=[];this.idle=true;this.addLists($$(document.id(a)||a));if(!this.options.clone){this.options.revert=false;}if(this.options.revert){this.effect=new Fx.Morph(null,Object.merge({duration:250,link:"cancel"},this.options.revert));
-}},attach:function(){this.addLists(this.lists);return this;},detach:function(){this.lists=this.removeLists(this.lists);return this;},addItems:function(){Array.flatten(arguments).each(function(a){this.elements.push(a);
-var b=a.retrieve("sortables:start",function(c){this.start.call(this,c,a);}.bind(this));(this.options.handle?a.getElement(this.options.handle)||a:a).addEvent("mousedown",b);
-},this);return this;},addLists:function(){Array.flatten(arguments).each(function(a){this.lists.include(a);this.addItems(a.getChildren());},this);return this;
-},removeItems:function(){return $$(Array.flatten(arguments).map(function(a){this.elements.erase(a);var b=a.retrieve("sortables:start");(this.options.handle?a.getElement(this.options.handle)||a:a).removeEvent("mousedown",b);
-return a;},this));},removeLists:function(){return $$(Array.flatten(arguments).map(function(a){this.lists.erase(a);this.removeItems(a.getChildren());return a;
-},this));},getClone:function(b,a){if(!this.options.clone){return new Element(a.tagName).inject(document.body);}if(typeOf(this.options.clone)=="function"){return this.options.clone.call(this,b,a,this.list);
-}var c=a.clone(true).setStyles({margin:0,position:"absolute",visibility:"hidden",width:a.getStyle("width")}).addEvent("mousedown",function(d){a.fireEvent("mousedown",d);
-});if(c.get("html").test("radio")){c.getElements("input[type=radio]").each(function(d,e){d.set("name","clone_"+e);if(d.get("checked")){a.getElements("input[type=radio]")[e].set("checked",true);
-}});}return c.inject(this.list).setPosition(a.getPosition(a.getOffsetParent()));},getDroppables:function(){var a=this.list.getChildren().erase(this.clone).erase(this.element);
-if(!this.options.constrain){a.append(this.lists).erase(this.list);}return a;},insert:function(c,b){var a="inside";if(this.lists.contains(b)){this.list=b;
-this.drag.droppables=this.getDroppables();}else{a=this.element.getAllPrevious().contains(b)?"before":"after";}this.element.inject(b,a);this.fireEvent("sort",[this.element,this.clone]);
-},start:function(b,a){if(!this.idle||b.rightClick||["button","input","a","textarea"].contains(b.target.get("tag"))){return;}this.idle=false;this.element=a;
-this.opacity=a.getStyle("opacity");this.list=a.getParent();this.clone=this.getClone(b,a);this.drag=new Drag.Move(this.clone,Object.merge({droppables:this.getDroppables()},this.options.dragOptions)).addEvents({onSnap:function(){b.stop();
-this.clone.setStyle("visibility","visible");this.element.setStyle("opacity",this.options.opacity||0);this.fireEvent("start",[this.element,this.clone]);
-}.bind(this),onEnter:this.insert.bind(this),onCancel:this.end.bind(this),onComplete:this.end.bind(this)});this.clone.inject(this.element,"before");this.drag.start(b);
-},end:function(){this.drag.detach();this.element.setStyle("opacity",this.opacity);if(this.effect){var b=this.element.getStyles("width","height"),d=this.clone,c=d.computePosition(this.element.getPosition(this.clone.getOffsetParent()));
-var a=function(){this.removeEvent("cancel",a);d.destroy();};this.effect.element=d;this.effect.start({top:c.top,left:c.left,width:b.width,height:b.height,opacity:0.25}).addEvent("cancel",a).chain(a);
-}else{this.clone.destroy();}this.reset();},reset:function(){this.idle=true;this.fireEvent("complete",this.element);},serialize:function(){var c=Array.link(arguments,{modifier:Type.isFunction,index:function(d){return d!=null;
-}});var b=this.lists.map(function(d){return d.getChildren().map(c.modifier||function(e){return e.get("id");},this);},this);var a=c.index;if(this.lists.length==1){a=0;
-}return(a||a===0)&&a>=0&&a<this.lists.length?b[a]:b;}});Request.implement({options:{initialDelay:5000,delay:5000,limit:60000},startTimer:function(b){var a=function(){if(!this.running){this.send({data:b});
-}};this.lastDelay=this.options.initialDelay;this.timer=a.delay(this.lastDelay,this);this.completeCheck=function(c){clearTimeout(this.timer);this.lastDelay=(c)?this.options.delay:(this.lastDelay+this.options.delay).min(this.options.limit);
-this.timer=a.delay(this.lastDelay,this);};return this.addEvent("complete",this.completeCheck);},stopTimer:function(){clearTimeout(this.timer);return this.removeEvent("complete",this.completeCheck);
-}});(function(){var a=this.Color=new Type("Color",function(c,d){if(arguments.length>=3){d="rgb";c=Array.slice(arguments,0,3);}else{if(typeof c=="string"){if(c.match(/rgb/)){c=c.rgbToHex().hexToRgb(true);
-}else{if(c.match(/hsb/)){c=c.hsbToRgb();}else{c=c.hexToRgb(true);}}}}d=d||"rgb";switch(d){case"hsb":var b=c;c=c.hsbToRgb();c.hsb=b;break;case"hex":c=c.hexToRgb(true);
-break;}c.rgb=c.slice(0,3);c.hsb=c.hsb||c.rgbToHsb();c.hex=c.rgbToHex();return Object.append(c,this);});a.implement({mix:function(){var b=Array.slice(arguments);
-var d=(typeOf(b.getLast())=="number")?b.pop():50;var c=this.slice();b.each(function(e){e=new a(e);for(var f=0;f<3;f++){c[f]=Math.round((c[f]/100*(100-d))+(e[f]/100*d));
-}});return new a(c,"rgb");},invert:function(){return new a(this.map(function(b){return 255-b;}));},setHue:function(b){return new a([b,this.hsb[1],this.hsb[2]],"hsb");
-},setSaturation:function(b){return new a([this.hsb[0],b,this.hsb[2]],"hsb");},setBrightness:function(b){return new a([this.hsb[0],this.hsb[1],b],"hsb");
-}});this.$RGB=function(e,d,c){return new a([e,d,c],"rgb");};this.$HSB=function(e,d,c){return new a([e,d,c],"hsb");};this.$HEX=function(b){return new a(b,"hex");
-};Array.implement({rgbToHsb:function(){var c=this[0],d=this[1],k=this[2],h=0;var j=Math.max(c,d,k),f=Math.min(c,d,k);var l=j-f;var i=j/255,g=(j!=0)?l/j:0;
-if(g!=0){var e=(j-c)/l;var b=(j-d)/l;var m=(j-k)/l;if(c==j){h=m-b;}else{if(d==j){h=2+e-m;}else{h=4+b-e;}}h/=6;if(h<0){h++;}}return[Math.round(h*360),Math.round(g*100),Math.round(i*100)];
-},hsbToRgb:function(){var d=Math.round(this[2]/100*255);if(this[1]==0){return[d,d,d];}else{var b=this[0]%360;var g=b%60;var h=Math.round((this[2]*(100-this[1]))/10000*255);
-var e=Math.round((this[2]*(6000-this[1]*g))/600000*255);var c=Math.round((this[2]*(6000-this[1]*(60-g)))/600000*255);switch(Math.floor(b/60)){case 0:return[d,c,h];
-case 1:return[e,d,h];case 2:return[h,d,c];case 3:return[h,e,d];case 4:return[c,h,d];case 5:return[d,h,e];}}return false;}});String.implement({rgbToHsb:function(){var b=this.match(/\d{1,3}/g);
-return(b)?b.rgbToHsb():null;},hsbToRgb:function(){var b=this.match(/\d{1,3}/g);return(b)?b.hsbToRgb():null;}});})();
\ No newline at end of file
diff --git a/module/web/media/js/package_ui.js b/module/web/media/js/package_ui.js
deleted file mode 100644
index 3ea965649..000000000
--- a/module/web/media/js/package_ui.js
+++ /dev/null
@@ -1,377 +0,0 @@
-var root = this;
-
-document.addEvent("domready", function() {
-    root.load = new Fx.Tween($("load-indicator"), {link: "cancel"});
-    root.load.set("opacity", 0);
-
-
-    root.packageBox = new MooDialog({destroyOnHide: false});
-    root.packageBox.setContent($('pack_box'));
-
-    $('pack_reset').addEvent('click', function() {
-        $('pack_form').reset();
-        root.packageBox.close();
-    });
-});
-
-function indicateLoad() {
-    //$("load-indicator").reveal();
-    root.load.start("opacity", 1)
-}
-
-function indicateFinish() {
-    root.load.start("opacity", 0)
-}
-
-function indicateSuccess() {
-    indicateFinish();
-    root.notify.alert('{{_("Success")}}.', {
-             'className': 'success'
-    });
-}
-
-function indicateFail() {
-    indicateFinish();
-    root.notify.alert('{{_("Failed")}}.', {
-             'className': 'error'
-    });
-}
-
-var PackageUI = new Class({
-    initialize: function(url, type) {
-        this.url = url;
-        this.type = type;
-        this.packages = [];
-        this.parsePackages();
-
-        this.sorts = new Sortables($("package-list"), {
-            constrain: false,
-            clone: true,
-            revert: true,
-            opacity: 0.4,
-            handle: ".package_drag",
-            onComplete: this.saveSort.bind(this)
-        });
-
-        $("del_finished").addEvent("click", this.deleteFinished.bind(this));
-        $("restart_failed").addEvent("click", this.restartFailed.bind(this));
-
-    },
-
-    parsePackages: function() {
-        $("package-list").getChildren("li").each(function(ele) {
-            var id = ele.getFirst().get("id").match(/[0-9]+/);
-            this.packages.push(new Package(this, id, ele))
-        }.bind(this))
-    },
-
-    loadPackages: function() {
-    },
-
-    deleteFinished: function() {
-        indicateLoad();
-        new Request.JSON({
-            method: 'get',
-            url: '/api/deleteFinished',
-            onSuccess: function(data) {
-                if (data.length > 0) {
-                    window.location.reload()
-                } else {
-                    this.packages.each(function(pack) {
-                        pack.close();
-                    });
-                    indicateSuccess();
-                }
-            }.bind(this),
-            onFailure: indicateFail
-        }).send();
-    },
-
-    restartFailed: function() {
-        indicateLoad();
-        new Request.JSON({
-            method: 'get',
-            url: '/api/restartFailed',
-            onSuccess: function(data) {
-                this.packages.each(function(pack) {
-                    pack.close();
-                });
-                indicateSuccess();
-            }.bind(this),
-            onFailure: indicateFail
-        }).send();
-    },
-
-    startSort: function(ele, copy) {
-    },
-
-    saveSort: function(ele, copy) {
-        var order = [];
-        this.sorts.serialize(function(li, pos) {
-            if (li == ele && ele.retrieve("order") != pos) {
-                order.push(ele.retrieve("pid") + "|" + pos)
-            }
-            li.store("order", pos)
-        });
-        if (order.length > 0) {
-            indicateLoad();
-            new Request.JSON({
-                method: 'get',
-                url: '/json/package_order/' + order[0],
-                onSuccess: indicateFinish,
-                onFailure: indicateFail
-            }).send();
-        }
-    }
-
-});
-
-var Package = new Class({
-    initialize: function(ui, id, ele, data) {
-        this.ui = ui;
-        this.id = id;
-        this.linksLoaded = false;
-
-        if (!ele) {
-            this.createElement(data);
-        } else {
-            this.ele = ele;
-            this.order = ele.getElements("div.order")[0].get("html");
-            this.ele.store("order", this.order);
-            this.ele.store("pid", this.id);
-            this.parseElement();
-        }
-
-        var pname = this.ele.getElements(".packagename")[0];
-        this.buttons = new Fx.Tween(this.ele.getElements(".buttons")[0], {link: "cancel"});
-        this.buttons.set("opacity", 0);
-
-        pname.addEvent("mouseenter", function(e) {
-            this.buttons.start("opacity", 1)
-        }.bind(this));
-
-        pname.addEvent("mouseleave", function(e) {
-            this.buttons.start("opacity", 0)
-        }.bind(this));
-
-
-    },
-
-    createElement: function() {
-        alert("create")
-    },
-
-    parseElement: function() {
-        var imgs = this.ele.getElements('img');
-
-        this.name = this.ele.getElements('.name')[0];
-        this.folder = this.ele.getElements('.folder')[0];
-        this.password = this.ele.getElements('.password')[0];
-
-        imgs[1].addEvent('click', this.deletePackage.bind(this));
-        imgs[2].addEvent('click', this.restartPackage.bind(this));
-        imgs[3].addEvent('click', this.editPackage.bind(this));
-        imgs[4].addEvent('click', this.movePackage.bind(this));
-
-        this.ele.getElement('.packagename').addEvent('click', this.toggle.bind(this));
-
-    },
-
-    loadLinks: function() {
-        indicateLoad();
-        new Request.JSON({
-            method: 'get',
-            url: '/json/package/' + this.id,
-            onSuccess: this.createLinks.bind(this),
-            onFailure: indicateFail
-        }).send();
-    },
-
-    createLinks: function(data) {
-        var ul = $("sort_children_{id}".substitute({"id": this.id}));
-        ul.set("html", "");
-        data.links.each(function(link) {
-            link.id = link.fid;
-            var li = new Element("li", {
-                "style": {
-                    "margin-left": 0
-                }
-            });
-
-            var html = "<span style='cursor: move' class='child_status sorthandle'><img src='/media/default/img/{icon}' style='width: 12px; height:12px;'/></span>\n".substitute({"icon": link.icon});
-            html += "<span style='font-size: 15px'>{name}</span><br /><div class='child_secrow'>".substitute({"name": link.name});
-            html += "<span class='child_status'>{statusmsg}</span>{error}&nbsp;".substitute({"statusmsg": link.statusmsg, "error":link.error});
-            html += "<span class='child_status'>{format_size}</span>".substitute({"format_size": link.format_size});
-            html += "<span class='child_status'>{plugin}</span>&nbsp;&nbsp;".substitute({"plugin": link.plugin});
-            html += "<img title='{{_("Delete Link")}}' style='cursor: pointer;' width='10px' height='10px' src='/media/default/img/delete.png' />&nbsp;&nbsp;";
-            html += "<img title='{{_("Restart Link")}}' style='cursor: pointer;margin-left: -4px' width='10px' height='10px' src='/media/default/img/arrow_refresh.png' /></div>";
-
-            var div = new Element("div", {
-                "id": "file_" + link.id,
-                "class": "child",
-                "html": html
-            });
-
-            li.store("order", link.order);
-            li.store("lid", link.id);
-
-            li.adopt(div);
-            ul.adopt(li);
-        });
-        this.sorts = new Sortables(ul, {
-            constrain: false,
-            clone: true,
-            revert: true,
-            opacity: 0.4,
-            handle: ".sorthandle",
-            onComplete: this.saveSort.bind(this)
-        });
-        this.registerLinkEvents();
-        this.linksLoaded = true;
-        indicateFinish();
-        this.toggle();
-    },
-
-    registerLinkEvents: function() {
-        this.ele.getElements('.child').each(function(child) {
-            var lid = child.get('id').match(/[0-9]+/);
-            var imgs = child.getElements('.child_secrow img');
-            imgs[0].addEvent('click', function(e) {
-                new Request({
-                    method: 'get',
-                    url: '/api/deleteFiles/[' + this + "]",
-                    onSuccess: function() {
-                        $('file_' + this).nix()
-                    }.bind(this),
-                    onFailure: indicateFail
-                }).send();
-            }.bind(lid));
-
-            imgs[1].addEvent('click', function(e) {
-                new Request({
-                    method: 'get',
-                    url: '/api/restartFile/' + this,
-                    onSuccess: function() {
-                        var ele = $('file_' + this);
-                        var imgs = ele.getElements("img");
-                        imgs[0].set("src", "/media/default/img/status_queue.png");
-                        var spans = ele.getElements(".child_status");
-                        spans[1].set("html", "queued");
-                        indicateSuccess();
-                    }.bind(this),
-                    onFailure: indicateFail
-                }).send();
-            }.bind(lid));
-        });
-    },
-
-    toggle: function() {
-        var child = this.ele.getElement('.children');
-        if (child.getStyle('display') == "block") {
-            child.dissolve();
-        } else {
-            if (!this.linksLoaded) {
-                this.loadLinks();
-            } else {
-                child.reveal();
-            }
-        }
-    },
-
-
-    deletePackage: function(event) {
-        indicateLoad();
-        new Request({
-            method: 'get',
-            url: '/api/deletePackages/[' + this.id + "]",
-            onSuccess: function() {
-                this.ele.nix();
-                indicateFinish();
-            }.bind(this),
-            onFailure: indicateFail
-        }).send();
-        //hide_pack();
-        event.stop();
-    },
-
-    restartPackage: function(event) {
-        indicateLoad();
-        new Request({
-            method: 'get',
-            url: '/api/restartPackage/' + this.id,
-            onSuccess: function() {
-                this.close();
-                indicateSuccess();
-            }.bind(this),
-            onFailure: indicateFail
-        }).send();
-        event.stop();
-    },
-
-    close: function() {
-        var child = this.ele.getElement('.children');
-        if (child.getStyle('display') == "block") {
-            child.dissolve();
-        }
-        var ul = $("sort_children_{id}".substitute({"id": this.id}));
-        ul.erase("html");
-        this.linksLoaded = false;
-    },
-
-    movePackage: function(event) {
-        indicateLoad();
-        new Request({
-            method: 'get',
-            url: '/json/move_package/' + ((this.ui.type + 1) % 2) + "/" + this.id,
-            onSuccess: function() {
-                this.ele.nix();
-                indicateFinish();
-            }.bind(this),
-            onFailure: indicateFail
-        }).send();
-        event.stop();
-    },
-
-    editPackage: function(event) {
-        $("pack_form").removeEvents("submit");
-        $("pack_form").addEvent("submit", this.savePackage.bind(this));
-
-        $("pack_id").set("value", this.id);
-        $("pack_name").set("value", this.name.get("text"));
-        $("pack_folder").set("value", this.folder.get("text"));
-        $("pack_pws").set("value", this.password.get("text"));
-
-        root.packageBox.open();
-        event.stop();
-    },
-
-    savePackage: function(event) {
-        $("pack_form").send();
-        this.name.set("text", $("pack_name").get("value"));
-        this.folder.set("text", $("pack_folder").get("value"));
-        this.password.set("text", $("pack_pws").get("value"));
-        root.packageBox.close();
-        event.stop();
-    },
-
-    saveSort: function(ele, copy) {
-        var order = [];
-        this.sorts.serialize(function(li, pos) {
-            if (li == ele && ele.retrieve("order") != pos) {
-                order.push(ele.retrieve("lid") + "|" + pos)
-            }
-            li.store("order", pos)
-        });
-        if (order.length > 0) {
-            indicateLoad();
-            new Request.JSON({
-                method: 'get',
-                url: '/json/link_order/' + order[0],
-                onSuccess: indicateFinish,
-                onFailure: indicateFail
-            }).send();
-        }
-    }
-
-});
-
diff --git a/module/web/media/js/purr_static.js b/module/web/media/js/purr_static.js
deleted file mode 100644
index 7e0aee949..000000000
--- a/module/web/media/js/purr_static.js
+++ /dev/null
@@ -1,308 +0,0 @@
-/*
----
-script: purr.js
-
-description: Class to create growl-style popup notifications.
-
-license: MIT-style
-
-authors: [atom smith]
-
-requires:
-- core/1.3: [Core, Browser, Array, Function, Number, String, Hash, Event, Class.Extras, Element.Event, Element.Style, Element.Dimensions, Fx.CSS, FX.Tween, Fx.Morph]
-
-provides: [Purr, Element.alert]
-...
-*/
-
-
-var Purr = new Class({
-
-	'options': {
-		'mode': 'top',
-		'position': 'left',
-		'elementAlertClass': 'purr-element-alert',
-		'elements': {
-			'wrapper': 'div',
-			'alert': 'div',
-			'buttonWrapper': 'div',
-			'button': 'button'
-		},
-		'elementOptions': {
-			'wrapper': {
-				'styles': {
-					'position': 'fixed',
-					'z-index': '9999'
-				},
-				'class': 'purr-wrapper'
-			},
-			'alert': {
-				'class': 'purr-alert',
-				'styles': {
-					'opacity': '.85'
-				}
-			},
-			'buttonWrapper': {
-				'class': 'purr-button-wrapper'
-			},
-			'button': {
-				'class': 'purr-button'
-			}
-		},
-		'alert': {
-			'buttons': [],
-			'clickDismiss': true,
-			'hoverWait': true,
-			'hideAfter': 5000,
-			'fx': {
-				'duration': 500
-			},
-			'highlightRepeat': false,
-			'highlight': { // false to disable highlighting
-				'start': '#FF0',
-				'end': false
-			}
-		}
-	},
-
-	'Implements': [Options, Events, Chain],
-
-	'initialize': function(options){
-		this.setOptions(options);
-		this.createWrapper();
-		return this;
-	},
-
-	'bindAlert': function(){
-		return this.alert.bind(this);
-	},
-
-	'createWrapper': function(){
-		this.wrapper = new Element(this.options.elements.wrapper, this.options.elementOptions.wrapper);
-		if(this.options.mode == 'top')
-		{
-			this.wrapper.setStyle('top', 0);
-		}
-		else
-		{
-			this.wrapper.setStyle('bottom', 0);
-		}
-		document.id(document.body).grab(this.wrapper);
-		this.positionWrapper(this.options.position);
-	},
-
-	'positionWrapper': function(position){
-		if(typeOf(position) == 'object')
-		{
-
-			var wrapperCoords = this.getWrapperCoords();
-
-			this.wrapper.setStyles({
-				'bottom': '',
-				'left': position.x,
-				'top': position.y - wrapperCoords.height,
-				'position': 'absolute'
-			});
-		}
-		else if(position == 'left')
-		{
-			this.wrapper.setStyle('left', 0);
-		}
-		else if(position == 'right')
-		{
-			this.wrapper.setStyle('right', 0);
-		}
-		else
-		{
-			this.wrapper.setStyle('left', (window.innerWidth / 2) - (this.getWrapperCoords().width / 2));
-		}
-		return this;
-	},
-
-	'getWrapperCoords': function(){
-		this.wrapper.setStyle('visibility', 'hidden');
-		var measurer = this.alert('need something in here to measure');
-		var coords = this.wrapper.getCoordinates();
-		measurer.destroy();
-		this.wrapper.setStyle('visibility','');
-		return coords;
-	},
-
-	'alert': function(msg, options){
-
-		options = Object.merge({}, this.options.alert, options || {});
-
-		var alert = new Element(this.options.elements.alert, this.options.elementOptions.alert);
-
-		if(typeOf(msg) == 'string')
-		{
-			alert.set('html', msg);
-		}
-		else if(typeOf(msg) == 'element')
-		{
-			alert.grab(msg);
-		}
-		else if(typeOf(msg) == 'array')
-		{
-			var alerts = [];
-			msg.each(function(m){
-				alerts.push(this.alert(m, options));
-			}, this);
-			return alerts;
-		}
-
-		alert.store('options', options);
-
-		if(options.buttons.length > 0)
-		{
-			options.clickDismiss = false;
-			options.hideAfter = false;
-			options.hoverWait = false;
-			var buttonWrapper = new Element(this.options.elements.buttonWrapper, this.options.elementOptions.buttonWrapper);
-			alert.grab(buttonWrapper);
-			options.buttons.each(function(button){
-				if(button.text !== undefined)
-				{
-					var callbackButton = new Element(this.options.elements.button, this.options.elementOptions.button);
-					callbackButton.set('html', button.text);
-					if(button.callback !== undefined)
-					{
-						callbackButton.addEvent('click', button.callback.pass(alert));
-					}
-					if(button.dismiss !== undefined && button.dismiss)
-					{
-						callbackButton.addEvent('click', this.dismiss.pass(alert, this));
-					}
-					buttonWrapper.grab(callbackButton);
-				}
-			}, this);
-		}
-		if(options.className !== undefined)
-		{
-			alert.addClass(options.className);
-		}
-
-		this.wrapper.grab(alert, (this.options.mode == 'top') ? 'bottom' : 'top');
-
-		var fx = Object.merge(this.options.alert.fx, options.fx);
-		var alertFx = new Fx.Morph(alert, fx);
-		alert.store('fx', alertFx);
-		this.fadeIn(alert);
-
-		if(options.highlight)
-		{
-			alertFx.addEvent('complete', function(){
-				alert.highlight(options.highlight.start, options.highlight.end);
-				if(options.highlightRepeat)
-				{
-					alert.highlight.periodical(options.highlightRepeat, alert, [options.highlight.start, options.highlight.end]);
-				}
-			});
-		}
-		if(options.hideAfter)
-		{
-			this.dismiss(alert);
-		}
-
-		if(options.clickDismiss)
-		{
-			alert.addEvent('click', function(){
-				this.holdUp = false;
-				this.dismiss(alert, true);
-			}.bind(this));
-		}
-
-		if(options.hoverWait)
-		{
-			alert.addEvents({
-				'mouseenter': function(){
-					this.holdUp = true;
-				}.bind(this),
-				'mouseleave': function(){
-					this.holdUp = false;
-				}.bind(this)
-			});
-		}
-
-		return alert;
-	},
-
-	'fadeIn': function(alert){
-		var alertFx = alert.retrieve('fx');
-		alertFx.set({
-			'opacity': 0
-		});
-		alertFx.start({
-			'opacity': [this.options.elementOptions.alert.styles.opacity, '.9'].pick()
-		});
-	},
-
-	'dismiss': function(alert, now){
-		now = now || false;
-		var options = alert.retrieve('options');
-		if(now)
-		{
-			this.fadeOut(alert);
-		}
-		else
-		{
-			this.fadeOut.delay(options.hideAfter, this, alert);
-		}
-	},
-
-	'fadeOut': function(alert){
-		if(this.holdUp)
-		{
-			this.dismiss.delay(100, this, [alert, true]);
-			return null;
-		}
-		var alertFx = alert.retrieve('fx');
-		if(!alertFx)
-		{
-			return null;
-		}
-		var to = {
-			'opacity': 0
-		};
-		if(this.options.mode == 'top')
-		{
-			to['margin-top'] = '-'+alert.offsetHeight+'px';
-		}
-		else
-		{
-			to['margin-bottom'] = '-'+alert.offsetHeight+'px';
-		}
-		alertFx.start(to);
-		alertFx.addEvent('complete', function(){
-			alert.destroy();
-		});
-	}
-});
-
-Element.implement({
-
-	'alert': function(msg, options){
-		var alert = this.retrieve('alert');
-		if(!alert)
-		{
-			options = options || {
-				'mode':'top'
-			};
-			alert = new Purr(options);
-			this.store('alert', alert);
-		}
-
-		var coords = this.getCoordinates();
-
-		alert.alert(msg, options);
-
-		alert.wrapper.setStyles({
-			'bottom': '',
-			'left': (coords.left - (alert.wrapper.getWidth() / 2)) + (this.getWidth() / 2),
-			'top': coords.top - (alert.wrapper.getHeight()),
-			'position': 'absolute'
-		});
-
-	}
-
-});
\ No newline at end of file
diff --git a/module/web/media/js/settings.coffee b/module/web/media/js/settings.coffee
deleted file mode 100644
index 9205233e3..000000000
--- a/module/web/media/js/settings.coffee
+++ /dev/null
@@ -1,107 +0,0 @@
-root = this
-
-window.addEvent 'domready', ->
-    root.accountDialog = new MooDialog {destroyOnHide: false}
-    root.accountDialog.setContent $ 'account_box'
-
-    new TinyTab $$('#toptabs li a'), $$('#tabs-body > span')
-
-    $$('ul.nav').each (nav) ->
-        new MooDropMenu nav, {
-            onOpen: (el) -> el.fade 'in'
-            onClose: (el) -> el.fade 'out'
-            onInitialize: (el) -> el.fade('hide').set 'tween', {duration:500}
-        }
-
-    new SettingsUI()
-
-
-class SettingsUI
-    constructor: ->
-        @menu = $$ "#general-menu li"
-        @menu.append $$ "#plugin-menu li"
-
-        @name = $ "tabsback"
-        @general = $ "general_form_content"
-        @plugin = $ "plugin_form_content"
-
-        el.addEvent 'click', @menuClick.bind(this) for el in @menu
-
-        $("general|submit").addEvent "click", @configSubmit.bind(this)
-        $("plugin|submit").addEvent "click", @configSubmit.bind(this)
-
-        $("account_add").addEvent "click", (e) ->
-            root.accountDialog.open()
-            e.stop()
-
-        $("account_reset").addEvent "click", (e) ->
-            root.accountDialog.close()
-
-        $("account_add_button").addEvent "click", @addAccount.bind(this)
-        $("account_submit").addEvent "click", @submitAccounts.bind(this)
-
-
-    menuClick: (e) ->
-        [category, section] = e.target.get("id").split("|")
-        name = e.target.get "text"
-
-
-        target = if category is "general" then @general else @plugin
-        target.dissolve()
-
-        new Request({
-            "method" : "get"
-            "url" : "/json/load_config/#{category}/#{section}"
-            "onSuccess": (data) =>
-                target.set "html", data
-                target.reveal()
-                this.name.set "text", name
-        }).send()
-
-
-    configSubmit: (e) ->
-        category = e.target.get("id").split("|")[0];
-        form = $("#{category}_form");
-
-        form.set "send", {
-            "method": "post"
-            "url": "/json/save_config/#{category}"
-            "onSuccess" : ->
-                root.notify.alert '{{ _("Settings saved.")}}', {
-                            'className': 'success'
-                        }
-            "onFailure": ->
-                root.notify.alert '{{ _("Error occured.")}}', {
-                            'className': 'error'
-                        }
-        }
-        form.send()
-        e.stop()
-
-    addAccount: (e) ->
-        form = $ "add_account_form"
-        form.set "send", {
-            "method": "post"
-            "onSuccess" : -> window.location.reload()
-            "onFailure": ->
-                root.notify.alert '{{_("Error occured.")}}', {
-                    'className': 'error'
-                    }
-            }
-
-        form.send()
-        e.stop()
-    
-    submitAccounts: (e) ->
-        form = $ "account_form"
-        form.set "send", {
-             "method": "post",
-             "onSuccess" : -> window.location.reload()
-             "onFailure": ->
-                 root.notify.alert('{{ _("Error occured.") }}', {
-                             'className': 'error'
-                         });
-             }
-
-        form.send()
-        e.stop()
\ No newline at end of file
diff --git a/module/web/media/js/settings.js b/module/web/media/js/settings.js
deleted file mode 100644
index 9191fac72..000000000
--- a/module/web/media/js/settings.js
+++ /dev/null
@@ -1,3 +0,0 @@
-{% autoescape true %}
-var SettingsUI,root;var __bind=function(a,b){return function(){return a.apply(b,arguments)}};root=this;window.addEvent("domready",function(){root.accountDialog=new MooDialog({destroyOnHide:false});root.accountDialog.setContent($("account_box"));new TinyTab($$("#toptabs li a"),$$("#tabs-body > span"));$$("ul.nav").each(function(a){return new MooDropMenu(a,{onOpen:function(b){return b.fade("in")},onClose:function(b){return b.fade("out")},onInitialize:function(b){return b.fade("hide").set("tween",{duration:500})}})});return new SettingsUI()});SettingsUI=(function(){function a(){var c,e,b,d;this.menu=$$("#general-menu li");this.menu.append($$("#plugin-menu li"));this.name=$("tabsback");this.general=$("general_form_content");this.plugin=$("plugin_form_content");d=this.menu;for(e=0,b=d.length;e<b;e++){c=d[e];c.addEvent("click",this.menuClick.bind(this))}$("general|submit").addEvent("click",this.configSubmit.bind(this));$("plugin|submit").addEvent("click",this.configSubmit.bind(this));$("account_add").addEvent("click",function(f){root.accountDialog.open();return f.stop()});$("account_reset").addEvent("click",function(f){return root.accountDialog.close()});$("account_add_button").addEvent("click",this.addAccount.bind(this));$("account_submit").addEvent("click",this.submitAccounts.bind(this))}a.prototype.menuClick=function(h){var c,b,g,f,d;d=h.target.get("id").split("|"),c=d[0],g=d[1];b=h.target.get("text");f=c==="general"?this.general:this.plugin;f.dissolve();return new Request({method:"get",url:"/json/load_config/"+c+"/"+g,onSuccess:__bind(function(e){f.set("html",e);f.reveal();return this.name.set("text",b)},this)}).send()};a.prototype.configSubmit=function(d){var c,b;c=d.target.get("id").split("|")[0];b=$(""+c+"_form");b.set("send",{method:"post",url:"/json/save_config/"+c,onSuccess:function(){return root.notify.alert('{{ _("Settings saved.")}}',{className:"success"})},onFailure:function(){return root.notify.alert('{{ _("Error occured.")}}',{className:"error"})}});b.send();return d.stop()};a.prototype.addAccount=function(c){var b;b=$("add_account_form");b.set("send",{method:"post",onSuccess:function(){return window.location.reload()},onFailure:function(){return root.notify.alert('{{_("Error occured.")}}',{className:"error"})}});b.send();return c.stop()};a.prototype.submitAccounts=function(c){var b;b=$("account_form");b.set("send",{method:"post",onSuccess:function(){return window.location.reload()},onFailure:function(){return root.notify.alert('{{ _("Error occured.") }}',{className:"error"})}});b.send();return c.stop()};return a})();
-{% endautoescape %}
\ No newline at end of file
diff --git a/module/web/media/js/tinytab_static.js b/module/web/media/js/tinytab_static.js
deleted file mode 100644
index 6c38292f5..000000000
--- a/module/web/media/js/tinytab_static.js
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
----
-description: TinyTab - Tiny and simple tab handler for Mootools.
-
-license: MIT-style
-
-authors:
-- Danillo César de O. Melo
-
-requires:
-- core/1.2.4: '*'
-
-provides: TinyTab
-
-...
-*/
-(function($) {
-	this.TinyTab = new Class({
-		Implements: Events,
-		initialize: function(tabs, contents, opt) {
-			this.tabs = tabs;
-			this.contents = contents;
-            this.header = $("tabsback");
-            this.headers = [];
-            for(var i =0; i < this.tabs.length; i++){
-                this.headers.push("");
-            }
-			if(!opt) opt = {};
-			this.css = opt.selectedClass || 'selected'; 
-			this.select(this.tabs[0]);
-			tabs.each(function(el){
-				el.addEvent('click',function(e){
-					this.select(el);
-					e.stop();
-				}.bind(this));
-			}.bind(this));
-		},
-
-		select: function(el) {
-			this.tabs.removeClass(this.css);
-			el.addClass(this.css);
-			this.contents.setStyle('display','none');
-            var index = this.tabs.indexOf(el);
-            this.header.set("text", this.headers[index]);
-			var content = this.contents[index];
-			content.setStyle('display','block');
-			this.fireEvent('change',[content,el]);
-		}
-	});
-})(document.id);
\ No newline at end of file
diff --git a/module/web/middlewares.py b/module/web/middlewares.py
index e0e6c3102..ae0911cc3 100644
--- a/module/web/middlewares.py
+++ b/module/web/middlewares.py
@@ -1,7 +1,11 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-import gzip
+# gzip is optional on some platform
+try:
+    import gzip
+except ImportError:
+    gzip = None
 
 try:
     from cStringIO import StringIO
@@ -31,9 +35,6 @@ class PrefixMiddleware(object):
 # (c) 2005 Ian Bicking and contributors; written for Paste (http://pythonpaste.org)
 # Licensed under the MIT license: http://www.opensource.org/licenses/mit-license.php
 
-# (c) 2005 Ian Bicking and contributors; written for Paste (http://pythonpaste.org)
-# Licensed under the MIT license: http://www.opensource.org/licenses/mit-license.php
-
 # WSGI middleware
 # Gzip-encodes the response.
 
@@ -86,18 +87,18 @@ class GzipResponse(object):
         ct = header_value(headers,'content-type')
         ce = header_value(headers,'content-encoding')
         cl = header_value(headers, 'content-length')
-        if cl:
-            cl = int(cl)
-        else:
-            cl = 201
-        self.compressible = False
-        if ct and (ct.startswith('text/') or ct.startswith('application/')) \
-            and 'zip' not in ct and cl > 200:
-            self.compressible = True
+
+        # don't compress on unknown size, it may be too huge
+        cl = int(cl) if cl else 0
+
         if ce:
             self.compressible = False
-        if self.compressible:
+        elif gzip is not None and ct and (ct.startswith('text/') or ct.startswith('application/')) \
+            and 'zip' not in ct and 200 < cl < 1024*1024:
+            self.compressible = True
             headers.append(('content-encoding', 'gzip'))
+            headers.append(('vary', 'Accept-Encoding'))
+
         remove_header(headers, 'content-length')
         self.headers = headers
         self.status = status
diff --git a/module/web/pyload_app.py b/module/web/pyload_app.py
index df4a4b3d4..0c3af103f 100644
--- a/module/web/pyload_app.py
+++ b/module/web/pyload_app.py
@@ -16,74 +16,53 @@
 
     @author: RaNaN
 """
-from datetime import datetime
-from operator import itemgetter, attrgetter
-
 import time
-import os
-import sys
-from os import listdir
-from os.path import isdir, isfile, join, abspath
-from sys import getfilesystemencoding
-from urllib import unquote
+from os.path import join
 
 from bottle import route, static_file, request, response, redirect, HTTPError, error
+from jinja2 import TemplateNotFound
 
-from webinterface import PYLOAD, PYLOAD_DIR, PROJECT_DIR, SETUP, env
-
-from utils import render_to_response, parse_permissions, parse_userdata, \
-    login_required, get_permission, set_permission, permlist, toDict, set_session
+from webinterface import PYLOAD, PROJECT_DIR, SETUP, env
 
-from filters import relpath, unquotepath
+from utils import render_to_response, login_required, set_session, get_user_api, is_mobile
 
-from module.utils import formatSize, save_join, fs_encode, fs_decode
 
+##########
 # Helper
+##########
 
+# TODO: useful but needs a rewrite, too
 def pre_processor():
     s = request.environ.get('beaker.session')
-    user = parse_userdata(s)
-    perms = parse_permissions(s)
-    status = {}
-    captcha = False
-    update = False
-    plugins = False
-    if user["is_authenticated"]:
-        status = PYLOAD.statusServer()
-        info = PYLOAD.getInfoByPlugin("UpdateManager")
-        captcha = PYLOAD.isCaptchaWaiting()
-
-        # check if update check is available
-        if info:
-            if info["pyload"] == "True": update = True
-            if info["plugins"] == "True": plugins = True
+    api = get_user_api(s)
+    user = None
+    status = None
 
+    if api is not None:
+        user = api.user
+        status = api.getServerStatus()
 
     return {"user": user,
-            'status': status,
-            'captcha': captcha,
-            'perms': perms,
-            'url': request.url,
-            'update': update,
-            'plugins': plugins}
+            'server': status,
+            'url': request.url ,
+            'ws': PYLOAD.getWSAddress()}
 
 
 def base(messages):
     return render_to_response('base.html', {'messages': messages}, [pre_processor])
 
 
-## Views
 @error(500)
 def error500(error):
-    print "An error occured while processing the request."
+    print "An error occurred while processing the request."
     if error.traceback:
         print error.traceback
 
-    return base(["An Error occured, please enable debug mode to get more details.", error,
+    return base(["An error occurred while processing the request.", error,
                  error.traceback.replace("\n", "<br>") if error.traceback else "No Traceback"])
 
-# render js
-@route("/media/js/<path:re:.+\.js>")
+# TODO: not working
+# @route("/static/js/<path:re:.+\.js>")
 def js_dynamic(path):
     response.headers['Expires'] = time.strftime("%a, %d %b %Y %H:%M:%S GMT",
                                                 time.gmtime(time.time() + 60 * 60 * 24 * 2))
@@ -92,442 +71,95 @@ def js_dynamic(path):
 
     try:
         # static files are not rendered
-        if "static" not in path and "mootools" not in path:
+        if "static" not in path:
             t = env.get_template("js/%s" % path)
             return t.render()
         else:
-            return static_file(path, root=join(PROJECT_DIR, "media", "js"))
+            return static_file(path, root=join(PROJECT_DIR, "static", "js"))
     except:
         return HTTPError(404, "Not Found")
 
-@route('/media/<path:path>')
+@route('/static/<path:path>')
 def server_static(path):
     response.headers['Expires'] = time.strftime("%a, %d %b %Y %H:%M:%S GMT",
                                                 time.gmtime(time.time() + 60 * 60 * 24 * 7))
     response.headers['Cache-control'] = "public"
-    return static_file(path, root=join(PROJECT_DIR, "media"))
+    return static_file(path, root=join(PROJECT_DIR, "static"))
+
+@route('/templates/<path:path>')
+def serve_template(path):
+    """ Serve backbone templates """
+    args = path.split("/")
+    args.insert(1, "backbone")
+    try:
+        return render_to_response("/".join(args))
+    except TemplateNotFound, e:
+        print e
+        return HTTPError(404, "Not Found")
+
+@route('/icons/<path:path>')
+def serve_icon(path):
+    # TODO
+    return redirect('/static/img/icon.png')
+    # return static_file(path, root=join("tmp", "icons"))
 
 @route('/favicon.ico')
 def favicon():
-    return static_file("favicon.ico", root=join(PROJECT_DIR, "media", "img"))
+    return static_file("favicon.ico", root=join(PROJECT_DIR, "static", "img"))
+
+
+##########
+# Views
+##########
 
 
 @route('/login', method="GET")
 def login():
+    # set mobilecookie to reduce is_mobile check-time
+    response.set_cookie("mobile", str(is_mobile()))
     if not PYLOAD and SETUP:
         redirect("/setup")
     else:
         return render_to_response("login.html", proc=[pre_processor])
 
-
 @route('/nopermission')
 def nopermission():
-    return base([_("You dont have permission to access this page.")])
+    return base([_("You don't have permission to access this page.")])
 
 
 @route("/login", method="POST")
 def login_post():
-    user = request.forms.get("username")
+    username = request.forms.get("username")
     password = request.forms.get("password")
-
-    info = PYLOAD.checkAuth(user, password)
-
-    if not info:
+    user = PYLOAD.checkAuth(username, password, request.environ.get('REMOTE_ADDR', None))
+    if not user:
         return render_to_response("login.html", {"errors": True}, [pre_processor])
-
-    set_session(request, info)
+    set_session(request, user)
     return redirect("/")
 
+@route("/toggle_mobile")
+def toggle_mobile():
+    response.set_cookie("mobile", str(not is_mobile()))
+    return redirect("/")
 
 @route("/logout")
 def logout():
     s = request.environ.get('beaker.session')
     s.delete()
-    return render_to_response("logout.html", proc=[pre_processor])
-
+    return render_to_response("login.html", {"logout": True}, proc=[pre_processor])
 
 @route("/")
-@route("/home")
-@login_required("LIST")
-def home():
-    try:
-        res = [toDict(x) for x in PYLOAD.statusDownloads()]
-    except:
-        s = request.environ.get('beaker.session')
-        s.delete()
-        return redirect("/login")
-
-    for link in res:
-        if link["status"] == 12:
-            link["information"] = "%s kB @ %s kB/s" % (link["size"] - link["bleft"], link["speed"])
-
-    return render_to_response("home.html", {"res": res}, [pre_processor])
-
-
-@route("/queue")
-@login_required("LIST")
-def queue():
-    queue = PYLOAD.getQueue()
-
-    queue.sort(key=attrgetter("order"))
-
-    return render_to_response('queue.html', {'content': queue, 'target': 1}, [pre_processor])
-
-
-@route("/collector")
-@login_required('LIST')
-def collector():
-    queue = PYLOAD.getCollector()
-
-    queue.sort(key=attrgetter("order"))
-
-    return render_to_response('queue.html', {'content': queue, 'target': 0}, [pre_processor])
-
-
-@route("/downloads")
-@login_required('DOWNLOAD')
-def downloads():
-    root = PYLOAD.getConfigValue("general", "download_folder")
-
-    if not isdir(root):
-        return base([_('Download directory not found.')])
-    data = {
-        'folder': [],
-        'files': []
-    }
-
-    items = listdir(fs_encode(root))
-
-    for item in sorted([fs_decode(x) for x in items]):
-        if isdir(save_join(root, item)):
-            folder = {
-                'name': item,
-                'path': item,
-                'files': []
-            }
-            files = listdir(save_join(root, item))
-            for file in sorted([fs_decode(x) for x in files]):
-                try:
-                    if isfile(save_join(root, item, file)):
-                        folder['files'].append(file)
-                except:
-                    pass
-
-            data['folder'].append(folder)
-        elif isfile(join(root, item)):
-            data['files'].append(item)
-
-    return render_to_response('downloads.html', {'files': data}, [pre_processor])
-
-
-@route("/downloads/get/<path:re:.+>")
-@login_required("DOWNLOAD")
-def get_download(path):
-    path = unquote(path).decode("utf8")
-    #@TODO some files can not be downloaded
-
-    root = PYLOAD.getConfigValue("general", "download_folder")
-
-    path = path.replace("..", "")
-    try:
-        return static_file(fs_encode(path), fs_encode(root))
-
-    except Exception, e:
-        print e
-        return HTTPError(404, "File not Found.")
-
-
+@login_required()
+def index(api):
+    return render_to_response("dashboard.html", proc=[pre_processor])
 
 @route("/settings")
-@login_required('SETTINGS')
-def config():
-    conf = PYLOAD.getConfig()
-    plugin = PYLOAD.getPluginConfig()
-
-    conf_menu = []
-    plugin_menu = []
-
-    for entry in sorted(conf.keys()):
-        conf_menu.append((entry, conf[entry].description))
-
-    for entry in sorted(plugin.keys()):
-        plugin_menu.append((entry, plugin[entry].description))
-
-    accs = PYLOAD.getAccounts(False)
-
-    for data in accs:
-        if data.trafficleft == -1:
-            data.trafficleft = _("unlimited")
-        elif not data.trafficleft:
-            data.trafficleft = _("not available")
-        else:
-            data.trafficleft = formatSize(data.trafficleft * 1024)
-
-        if data.validuntil == -1:
-            data.validuntil  = _("unlimited")
-        elif not data.validuntil :
-            data.validuntil  = _("not available")
-        else:
-            t = time.localtime(data.validuntil)
-            data.validuntil  = time.strftime("%d.%m.%Y", t)
-
-        if "time" in data.options:
-            try:
-                data.options["time"] = data.options["time"][0]
-            except:
-                data.options["time"] = "0:00-0:00"
-
-        if "limitDL" in data.options:
-            data.options["limitdl"] = data.options["limitDL"][0]
-        else:
-            data.options["limitdl"] = "0"
-
-    return render_to_response('settings.html',
-            {'conf': {'plugin': plugin_menu, 'general': conf_menu, 'accs': accs}, 'types': PYLOAD.getAccountTypes()},
-        [pre_processor])
-
-
-@route("/filechooser")
-@route("/pathchooser")
-@route("/filechooser/:file#.+#")
-@route("/pathchooser/:path#.+#")
-@login_required('STATUS')
-def path(file="", path=""):
-    if file:
-        type = "file"
-    else:
-        type = "folder"
-
-    path = os.path.normpath(unquotepath(path))
-
-    if os.path.isfile(path):
-        oldfile = path
-        path = os.path.dirname(path)
-    else:
-        oldfile = ''
-
-    abs = False
-
-    if os.path.isdir(path):
-        if os.path.isabs(path):
-            cwd = os.path.abspath(path)
-            abs = True
-        else:
-            cwd = relpath(path)
-    else:
-        cwd = os.getcwd()
-
-    try:
-        cwd = cwd.encode("utf8")
-    except:
-        pass
-
-    cwd = os.path.normpath(os.path.abspath(cwd))
-    parentdir = os.path.dirname(cwd)
-    if not abs:
-        if os.path.abspath(cwd) == "/":
-            cwd = relpath(cwd)
-        else:
-            cwd = relpath(cwd) + os.path.sep
-        parentdir = relpath(parentdir) + os.path.sep
-
-    if os.path.abspath(cwd) == "/":
-        parentdir = ""
-
-    try:
-        folders = os.listdir(cwd)
-    except:
-        folders = []
-
-    files = []
-
-    for f in folders:
-        try:
-            f = f.decode(getfilesystemencoding())
-            data = {'name': f, 'fullpath': join(cwd, f)}
-            data['sort'] = data['fullpath'].lower()
-            data['modified'] = datetime.fromtimestamp(int(os.path.getmtime(join(cwd, f))))
-            data['ext'] = os.path.splitext(f)[1]
-        except:
-            continue
-
-        if os.path.isdir(join(cwd, f)):
-            data['type'] = 'dir'
-        else:
-            data['type'] = 'file'
-
-        if os.path.isfile(join(cwd, f)):
-            data['size'] = os.path.getsize(join(cwd, f))
-
-            power = 0
-            while (data['size'] / 1024) > 0.3:
-                power += 1
-                data['size'] /= 1024.
-            units = ('', 'K', 'M', 'G', 'T')
-            data['unit'] = units[power] + 'Byte'
-        else:
-            data['size'] = ''
-
-        files.append(data)
-
-    files = sorted(files, key=itemgetter('type', 'sort'))
-
-    return render_to_response('pathchooser.html',
-            {'cwd': cwd, 'files': files, 'parentdir': parentdir, 'type': type, 'oldfile': oldfile,
-             'absolute': abs}, [])
-
-
-@route("/logs")
-@route("/logs", method="POST")
-@route("/logs/:item")
-@route("/logs/:item", method="POST")
-@login_required('LOGS')
-def logs(item=-1):
-    s = request.environ.get('beaker.session')
-
-    perpage = s.get('perpage', 34)
-    reversed = s.get('reversed', False)
-
-    warning = ""
-    conf = PYLOAD.getConfigValue("log","file_log")
-    if not conf:
-        warning = "Warning: File log is disabled, see settings page."
-
-    perpage_p = ((20, 20), (34, 34), (40, 40), (100, 100), (0, 'all'))
-    fro = None
-
-    if request.environ.get('REQUEST_METHOD', "GET") == "POST":
-        try:
-            fro = datetime.strptime(request.forms['from'], '%d.%m.%Y %H:%M:%S')
-        except:
-            pass
-        try:
-            perpage = int(request.forms['perpage'])
-            s['perpage'] = perpage
-
-            reversed = bool(request.forms.get('reversed', False))
-            s['reversed'] = reversed
-        except:
-            pass
-
-        s.save()
-
-    try:
-        item = int(item)
-    except:
-        pass
-
-    log = PYLOAD.getLog()
-    if not perpage:
-        item = 0
-
-    if item < 1 or type(item) is not int:
-        item = 1 if len(log) - perpage + 1 < 1 else len(log) - perpage + 1
-
-    if type(fro) is datetime: # we will search for datetime
-        item = -1
-
-    data = []
-    counter = 0
-    perpagecheck = 0
-    for l in log:
-        counter += 1
-
-        if counter >= item:
-            try:
-                date, time, level, message = l.decode("utf8", "ignore").split(" ", 3)
-                dtime = datetime.strptime(date + ' ' + time, '%d.%m.%Y %H:%M:%S')
-            except:
-                dtime = None
-                date = '?'
-                time = ' '
-                level = '?'
-                message = l
-            if item == -1 and dtime is not None and fro <= dtime:
-                item = counter #found our datetime
-            if item >= 0:
-                data.append({'line': counter, 'date': date + " " + time, 'level': level, 'message': message})
-                perpagecheck += 1
-                if fro is None and dtime is not None: #if fro not set set it to first showed line
-                    fro = dtime
-            if perpagecheck >= perpage > 0:
-                break
-
-    if fro is None: #still not set, empty log?
-        fro = datetime.now()
-    if reversed:
-        data.reverse()
-    return render_to_response('logs.html', {'warning': warning, 'log': data, 'from': fro.strftime('%d.%m.%Y %H:%M:%S'),
-                                            'reversed': reversed, 'perpage': perpage, 'perpage_p': sorted(perpage_p),
-                                            'iprev': 1 if item - perpage < 1 else item - perpage,
-                                            'inext': (item + perpage) if item + perpage < len(log) else item},
-        [pre_processor])
-
+@login_required()
+def settings(api):
+    return render_to_response("settings.html", proc=[pre_processor])
 
 @route("/admin")
-@route("/admin", method="POST")
-@login_required("ADMIN")
-def admin():
-    # convert to dict
-    user = dict([(name, toDict(y)) for name, y in PYLOAD.getAllUserData().iteritems()])
-    perms = permlist()
-
-    for data in user.itervalues():
-        data["perms"] = {}
-        get_permission(data["perms"], data["permission"])
-        data["perms"]["admin"] = True if data["role"] is 0 else False
-
+@login_required()
+def admin(api):
+    return render_to_response("admin.html", proc=[pre_processor])
 
-    s = request.environ.get('beaker.session')
-    if request.environ.get('REQUEST_METHOD', "GET") == "POST":
-        for name in user:
-            if request.POST.get("%s|admin" % name, False):
-                user[name]["role"] = 0
-                user[name]["perms"]["admin"] = True
-            elif name != s["name"]:
-                user[name]["role"] = 1
-                user[name]["perms"]["admin"] = False
-
-            # set all perms to false
-            for perm in perms:
-                user[name]["perms"][perm] = False
-
-            
-            for perm in request.POST.getall("%s|perms" % name):
-                user[name]["perms"][perm] = True
-
-            user[name]["permission"] = set_permission(user[name]["perms"])
-
-            PYLOAD.setUserPermission(name, user[name]["permission"], user[name]["role"])
-
-    return render_to_response("admin.html", {"users": user, "permlist": perms}, [pre_processor])
-
-
-@route("/setup")
-def setup():
-    if PYLOAD or not SETUP:
-        return base([_("Run pyLoadCore.py -s to access the setup.")])
-
-    return render_to_response('setup.html', {"user": False, "perms": False})
-
-
-@route("/info")
-def info():
-    conf = PYLOAD.getConfigDict()
-
-    if hasattr(os, "uname"):
-        extra = os.uname()
-    else:
-        extra = tuple()
-
-    data = {"python": sys.version,
-            "os": " ".join((os.name, sys.platform) + extra),
-            "version": PYLOAD.getServerVersion(),
-            "folder": abspath(PYLOAD_DIR), "config": abspath(""),
-            "download": abspath(conf["general"]["download_folder"]["value"]),
-            "freespace": formatSize(PYLOAD.freeSpace()),
-            "remote": conf["remote"]["port"]["value"],
-            "webif": conf["webinterface"]["port"]["value"],
-            "language": conf["general"]["language"]["value"]}
-
-    return render_to_response("info.html", data, [pre_processor])
diff --git a/module/web/servers.py b/module/web/servers.py
new file mode 100644
index 000000000..a3c51e36b
--- /dev/null
+++ b/module/web/servers.py
@@ -0,0 +1,162 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from bottle import ServerAdapter as BaseAdapter
+
+class ServerAdapter(BaseAdapter):
+    SSL = False
+    NAME = ""
+
+    def __init__(self, host, port, key, cert, connections, debug, **kwargs):
+        BaseAdapter.__init__(self, host, port, **kwargs)
+        self.key = key
+        self.cert = cert
+        self.connection = connections
+        self.debug = debug
+
+    @classmethod
+    def find(cls):
+        """ Check if server is available by trying to import it
+
+        :raises Exception: importing  C dependant library could also fail with other reasons
+        :return: True on success
+        """
+        try:
+            __import__(cls.NAME)
+            return True
+        except ImportError:
+            return False
+
+    def run(self, handler):
+        raise NotImplementedError
+
+
+class CherryPyWSGI(ServerAdapter):
+    SSL = True
+    NAME = "threaded"
+
+    @classmethod
+    def find(cls):
+        return True
+
+    def run(self, handler):
+        from wsgiserver import CherryPyWSGIServer
+
+        if self.cert and self.key:
+            CherryPyWSGIServer.ssl_certificate = self.cert
+            CherryPyWSGIServer.ssl_private_key = self.key
+
+        server = CherryPyWSGIServer((self.host, self.port), handler, numthreads=self.connection)
+        server.start()
+
+
+class FapwsServer(ServerAdapter):
+    """ Does not work very good currently  """
+
+    NAME = "fapws"
+
+    def run(self, handler): # pragma: no cover
+        import fapws._evwsgi as evwsgi
+        from fapws import base, config
+
+        port = self.port
+        if float(config.SERVER_IDENT[-2:]) > 0.4:
+            # fapws3 silently changed its API in 0.5
+            port = str(port)
+        evwsgi.start(self.host, port)
+        evwsgi.set_base_module(base)
+
+        def app(environ, start_response):
+            environ['wsgi.multiprocess'] = False
+            return handler(environ, start_response)
+
+        evwsgi.wsgi_cb(('', app))
+        evwsgi.run()
+
+
+# TODO: ssl
+class MeinheldServer(ServerAdapter):
+    SSL = True
+    NAME = "meinheld"
+
+    def run(self, handler):
+        from meinheld import server
+
+        if self.quiet:
+            server.set_access_logger(None)
+            server.set_error_logger(None)
+
+        server.listen((self.host, self.port))
+        server.run(handler)
+
+# todo:ssl
+class TornadoServer(ServerAdapter):
+    """ The super hyped asynchronous server by facebook. Untested. """
+
+    SSL = True
+    NAME = "tornado"
+
+    def run(self, handler): # pragma: no cover
+        import tornado.wsgi, tornado.httpserver, tornado.ioloop
+
+        container = tornado.wsgi.WSGIContainer(handler)
+        server = tornado.httpserver.HTTPServer(container)
+        server.listen(port=self.port)
+        tornado.ioloop.IOLoop.instance().start()
+
+
+class BjoernServer(ServerAdapter):
+    """ Fast server written in C: https://github.com/jonashaag/bjoern """
+
+    NAME = "bjoern"
+
+    def run(self, handler):
+        from bjoern import run
+
+        run(handler, self.host, self.port)
+
+
+# todo: ssl
+class EventletServer(ServerAdapter):
+
+    SSL = True
+    NAME = "eventlet"
+
+    def run(self, handler):
+        from eventlet import wsgi, listen
+
+        try:
+            wsgi.server(listen((self.host, self.port)), handler,
+                log_output=(not self.quiet))
+        except TypeError:
+            # Needed to ignore the log
+            class NoopLog:
+                def write(self, *args):
+                    pass
+
+            # Fallback, if we have old version of eventlet
+            wsgi.server(listen((self.host, self.port)), handler, log=NoopLog())
+
+
+class FlupFCGIServer(ServerAdapter):
+
+    SSL = False
+    NAME = "flup"
+
+    def run(self, handler): # pragma: no cover
+        import flup.server.fcgi
+        from flup.server.threadedserver import ThreadedServer
+
+        def noop(*args, **kwargs):
+            pass
+
+        # Monkey patch signal handler, it does not work from threads
+        ThreadedServer._installSignalHandlers = noop
+
+        self.options.setdefault('bindAddress', (self.host, self.port))
+        flup.server.fcgi.WSGIServer(handler, **self.options).run()
+
+# Order is important and gives every server precedence over others!
+all_server = [BjoernServer, TornadoServer, EventletServer, CherryPyWSGI]
+# Some are deactivated because they have some flaws
+##all_server = [FapwsServer, MeinheldServer, BjoernServer, TornadoServer, EventletServer, CherryPyWSGI]
\ No newline at end of file
diff --git a/module/web/setup_app.py b/module/web/setup_app.py
new file mode 100644
index 000000000..68da474bb
--- /dev/null
+++ b/module/web/setup_app.py
@@ -0,0 +1,24 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from bottle import route, request, response, HTTPError, redirect
+
+from webinterface import PROJECT_DIR, SETUP, env
+from utils import render_to_response
+
+def setup_required(func):
+    def _view(*args, **kwargs):
+
+        # setup needs to be running
+        if SETUP is None:
+            redirect("/nopermission")
+
+        return func(*args, **kwargs)
+    return _view
+
+
+@route("/setup")
+@setup_required
+def setup():
+    
+    return render_to_response('setup.html')
diff --git a/module/web/static/css/bootstrap.css b/module/web/static/css/bootstrap.css
new file mode 100755
index 000000000..70dfd726b
--- /dev/null
+++ b/module/web/static/css/bootstrap.css
@@ -0,0 +1,6307 @@
+/*!
+ * Bootstrap v2.3.0
+ *
+ * Copyright 2012 Twitter, Inc
+ * Licensed under the Apache License v2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Designed and built with all the love in the world @twitter by @mdo and @fat.
+ */
+.clearfix {
+  *zoom: 1;
+}
+.clearfix:before,
+.clearfix:after {
+  display: table;
+  content: "";
+  line-height: 0;
+}
+.clearfix:after {
+  clear: both;
+}
+.hide-text {
+  font: 0/0 a;
+  color: transparent;
+  text-shadow: none;
+  background-color: transparent;
+  border: 0;
+}
+.input-block-level {
+  display: block;
+  width: 100%;
+  min-height: 30px;
+  -webkit-box-sizing: border-box;
+  -moz-box-sizing: border-box;
+  box-sizing: border-box;
+}
+article,
+aside,
+details,
+figcaption,
+figure,
+footer,
+header,
+hgroup,
+nav,
+section {
+  display: block;
+}
+audio,
+canvas,
+video {
+  display: inline-block;
+  *display: inline;
+  *zoom: 1;
+}
+audio:not([controls]) {
+  display: none;
+}
+html {
+  font-size: 100%;
+  -webkit-text-size-adjust: 100%;
+  -ms-text-size-adjust: 100%;
+}
+a:focus {
+  outline: thin dotted #333;
+  outline: 5px auto -webkit-focus-ring-color;
+  outline-offset: -2px;
+}
+a:hover,
+a:active {
+  outline: 0;
+}
+sub,
+sup {
+  position: relative;
+  font-size: 75%;
+  line-height: 0;
+  vertical-align: baseline;
+}
+sup {
+  top: -0.5em;
+}
+sub {
+  bottom: -0.25em;
+}
+img {
+  /* Responsive images (ensure images don't scale beyond their parents) */
+
+  max-width: 100%;
+  /* Part 1: Set a maxium relative to the parent */
+
+  width: auto\9;
+  /* IE7-8 need help adjusting responsive images */
+
+  height: auto;
+  /* Part 2: Scale the height according to the width, otherwise you get stretching */
+
+  vertical-align: middle;
+  border: 0;
+  -ms-interpolation-mode: bicubic;
+}
+#map_canvas img,
+.google-maps img {
+  max-width: none;
+}
+button,
+input,
+select,
+textarea {
+  margin: 0;
+  font-size: 100%;
+  vertical-align: middle;
+}
+button,
+input {
+  *overflow: visible;
+  line-height: normal;
+}
+button::-moz-focus-inner,
+input::-moz-focus-inner {
+  padding: 0;
+  border: 0;
+}
+button,
+html input[type="button"],
+input[type="reset"],
+input[type="submit"] {
+  -webkit-appearance: button;
+  cursor: pointer;
+}
+label,
+select,
+button,
+input[type="button"],
+input[type="reset"],
+input[type="submit"],
+input[type="radio"],
+input[type="checkbox"] {
+  cursor: pointer;
+}
+input[type="search"] {
+  -webkit-box-sizing: content-box;
+  -moz-box-sizing: content-box;
+  box-sizing: content-box;
+  -webkit-appearance: textfield;
+}
+input[type="search"]::-webkit-search-decoration,
+input[type="search"]::-webkit-search-cancel-button {
+  -webkit-appearance: none;
+}
+textarea {
+  overflow: auto;
+  vertical-align: top;
+}
+@media print {
+  * {
+    text-shadow: none !important;
+    color: #000 !important;
+    background: transparent !important;
+    box-shadow: none !important;
+  }
+  a,
+  a:visited {
+    text-decoration: underline;
+  }
+  a[href]:after {
+    content: " (" attr(href) ")";
+  }
+  abbr[title]:after {
+    content: " (" attr(title) ")";
+  }
+  .ir a:after,
+  a[href^="javascript:"]:after,
+  a[href^="#"]:after {
+    content: "";
+  }
+  pre,
+  blockquote {
+    border: 1px solid #999;
+    page-break-inside: avoid;
+  }
+  thead {
+    display: table-header-group;
+  }
+  tr,
+  img {
+    page-break-inside: avoid;
+  }
+  img {
+    max-width: 100% !important;
+  }
+  @page  {
+    margin: 0.5cm;
+  }
+  p,
+  h2,
+  h3 {
+    orphans: 3;
+    widows: 3;
+  }
+  h2,
+  h3 {
+    page-break-after: avoid;
+  }
+}
+body {
+  margin: 0;
+  font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+  font-size: 14px;
+  line-height: 20px;
+  color: #333333;
+  background-color: #ffffff;
+}
+a {
+  color: #0088cc;
+  text-decoration: none;
+}
+a:hover,
+a:focus {
+  color: #005580;
+  text-decoration: underline;
+}
+.img-rounded {
+  -webkit-border-radius: 6px;
+  -moz-border-radius: 6px;
+  border-radius: 6px;
+}
+.img-polaroid {
+  padding: 4px;
+  background-color: #fff;
+  border: 1px solid #ccc;
+  border: 1px solid rgba(0, 0, 0, 0.2);
+  -webkit-box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+  -moz-box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+}
+.img-circle {
+  -webkit-border-radius: 500px;
+  -moz-border-radius: 500px;
+  border-radius: 500px;
+}
+.row {
+  margin-left: -20px;
+  *zoom: 1;
+}
+.row:before,
+.row:after {
+  display: table;
+  content: "";
+  line-height: 0;
+}
+.row:after {
+  clear: both;
+}
+[class*="span"] {
+  float: left;
+  min-height: 1px;
+  margin-left: 20px;
+}
+.container,
+.navbar-static-top .container,
+.navbar-fixed-top .container,
+.navbar-fixed-bottom .container {
+  width: 940px;
+}
+.span12 {
+  width: 940px;
+}
+.span11 {
+  width: 860px;
+}
+.span10 {
+  width: 780px;
+}
+.span9 {
+  width: 700px;
+}
+.span8 {
+  width: 620px;
+}
+.span7 {
+  width: 540px;
+}
+.span6 {
+  width: 460px;
+}
+.span5 {
+  width: 380px;
+}
+.span4 {
+  width: 300px;
+}
+.span3 {
+  width: 220px;
+}
+.span2 {
+  width: 140px;
+}
+.span1 {
+  width: 60px;
+}
+.offset12 {
+  margin-left: 980px;
+}
+.offset11 {
+  margin-left: 900px;
+}
+.offset10 {
+  margin-left: 820px;
+}
+.offset9 {
+  margin-left: 740px;
+}
+.offset8 {
+  margin-left: 660px;
+}
+.offset7 {
+  margin-left: 580px;
+}
+.offset6 {
+  margin-left: 500px;
+}
+.offset5 {
+  margin-left: 420px;
+}
+.offset4 {
+  margin-left: 340px;
+}
+.offset3 {
+  margin-left: 260px;
+}
+.offset2 {
+  margin-left: 180px;
+}
+.offset1 {
+  margin-left: 100px;
+}
+.row-fluid {
+  width: 100%;
+  *zoom: 1;
+}
+.row-fluid:before,
+.row-fluid:after {
+  display: table;
+  content: "";
+  line-height: 0;
+}
+.row-fluid:after {
+  clear: both;
+}
+.row-fluid [class*="span"] {
+  display: block;
+  width: 100%;
+  min-height: 30px;
+  -webkit-box-sizing: border-box;
+  -moz-box-sizing: border-box;
+  box-sizing: border-box;
+  float: left;
+  margin-left: 2.127659574468085%;
+  *margin-left: 2.074468085106383%;
+}
+.row-fluid [class*="span"]:first-child {
+  margin-left: 0;
+}
+.row-fluid .controls-row [class*="span"] + [class*="span"] {
+  margin-left: 2.127659574468085%;
+}
+.row-fluid .span12 {
+  width: 100%;
+  *width: 99.94680851063829%;
+}
+.row-fluid .span11 {
+  width: 91.48936170212765%;
+  *width: 91.43617021276594%;
+}
+.row-fluid .span10 {
+  width: 82.97872340425532%;
+  *width: 82.92553191489361%;
+}
+.row-fluid .span9 {
+  width: 74.46808510638297%;
+  *width: 74.41489361702126%;
+}
+.row-fluid .span8 {
+  width: 65.95744680851064%;
+  *width: 65.90425531914893%;
+}
+.row-fluid .span7 {
+  width: 57.44680851063829%;
+  *width: 57.39361702127659%;
+}
+.row-fluid .span6 {
+  width: 48.93617021276595%;
+  *width: 48.88297872340425%;
+}
+.row-fluid .span5 {
+  width: 40.42553191489362%;
+  *width: 40.37234042553192%;
+}
+.row-fluid .span4 {
+  width: 31.914893617021278%;
+  *width: 31.861702127659576%;
+}
+.row-fluid .span3 {
+  width: 23.404255319148934%;
+  *width: 23.351063829787233%;
+}
+.row-fluid .span2 {
+  width: 14.893617021276595%;
+  *width: 14.840425531914894%;
+}
+.row-fluid .span1 {
+  width: 6.382978723404255%;
+  *width: 6.329787234042553%;
+}
+.row-fluid .offset12 {
+  margin-left: 104.25531914893617%;
+  *margin-left: 104.14893617021275%;
+}
+.row-fluid .offset12:first-child {
+  margin-left: 102.12765957446808%;
+  *margin-left: 102.02127659574467%;
+}
+.row-fluid .offset11 {
+  margin-left: 95.74468085106382%;
+  *margin-left: 95.6382978723404%;
+}
+.row-fluid .offset11:first-child {
+  margin-left: 93.61702127659574%;
+  *margin-left: 93.51063829787232%;
+}
+.row-fluid .offset10 {
+  margin-left: 87.23404255319149%;
+  *margin-left: 87.12765957446807%;
+}
+.row-fluid .offset10:first-child {
+  margin-left: 85.1063829787234%;
+  *margin-left: 84.99999999999999%;
+}
+.row-fluid .offset9 {
+  margin-left: 78.72340425531914%;
+  *margin-left: 78.61702127659572%;
+}
+.row-fluid .offset9:first-child {
+  margin-left: 76.59574468085106%;
+  *margin-left: 76.48936170212764%;
+}
+.row-fluid .offset8 {
+  margin-left: 70.2127659574468%;
+  *margin-left: 70.10638297872339%;
+}
+.row-fluid .offset8:first-child {
+  margin-left: 68.08510638297872%;
+  *margin-left: 67.9787234042553%;
+}
+.row-fluid .offset7 {
+  margin-left: 61.70212765957446%;
+  *margin-left: 61.59574468085106%;
+}
+.row-fluid .offset7:first-child {
+  margin-left: 59.574468085106375%;
+  *margin-left: 59.46808510638297%;
+}
+.row-fluid .offset6 {
+  margin-left: 53.191489361702125%;
+  *margin-left: 53.085106382978715%;
+}
+.row-fluid .offset6:first-child {
+  margin-left: 51.063829787234035%;
+  *margin-left: 50.95744680851063%;
+}
+.row-fluid .offset5 {
+  margin-left: 44.68085106382979%;
+  *margin-left: 44.57446808510638%;
+}
+.row-fluid .offset5:first-child {
+  margin-left: 42.5531914893617%;
+  *margin-left: 42.4468085106383%;
+}
+.row-fluid .offset4 {
+  margin-left: 36.170212765957444%;
+  *margin-left: 36.06382978723405%;
+}
+.row-fluid .offset4:first-child {
+  margin-left: 34.04255319148936%;
+  *margin-left: 33.93617021276596%;
+}
+.row-fluid .offset3 {
+  margin-left: 27.659574468085104%;
+  *margin-left: 27.5531914893617%;
+}
+.row-fluid .offset3:first-child {
+  margin-left: 25.53191489361702%;
+  *margin-left: 25.425531914893618%;
+}
+.row-fluid .offset2 {
+  margin-left: 19.148936170212764%;
+  *margin-left: 19.04255319148936%;
+}
+.row-fluid .offset2:first-child {
+  margin-left: 17.02127659574468%;
+  *margin-left: 16.914893617021278%;
+}
+.row-fluid .offset1 {
+  margin-left: 10.638297872340425%;
+  *margin-left: 10.53191489361702%;
+}
+.row-fluid .offset1:first-child {
+  margin-left: 8.51063829787234%;
+  *margin-left: 8.404255319148938%;
+}
+[class*="span"].hide,
+.row-fluid [class*="span"].hide {
+  display: none;
+}
+[class*="span"].pull-right,
+.row-fluid [class*="span"].pull-right {
+  float: right;
+}
+.container {
+  margin-right: auto;
+  margin-left: auto;
+  *zoom: 1;
+}
+.container:before,
+.container:after {
+  display: table;
+  content: "";
+  line-height: 0;
+}
+.container:after {
+  clear: both;
+}
+.container-fluid {
+  padding-right: 20px;
+  padding-left: 20px;
+  *zoom: 1;
+}
+.container-fluid:before,
+.container-fluid:after {
+  display: table;
+  content: "";
+  line-height: 0;
+}
+.container-fluid:after {
+  clear: both;
+}
+p {
+  margin: 0 0 10px;
+}
+.lead {
+  margin-bottom: 20px;
+  font-size: 21px;
+  font-weight: 200;
+  line-height: 30px;
+}
+small {
+  font-size: 85%;
+}
+strong {
+  font-weight: bold;
+}
+em {
+  font-style: italic;
+}
+cite {
+  font-style: normal;
+}
+.muted {
+  color: #999999;
+}
+a.muted:hover,
+a.muted:focus {
+  color: #808080;
+}
+.text-warning {
+  color: #c09853;
+}
+a.text-warning:hover,
+a.text-warning:focus {
+  color: #a47e3c;
+}
+.text-error {
+  color: #b94a48;
+}
+a.text-error:hover,
+a.text-error:focus {
+  color: #953b39;
+}
+.text-info {
+  color: #3a87ad;
+}
+a.text-info:hover,
+a.text-info:focus {
+  color: #2d6987;
+}
+.text-success {
+  color: #468847;
+}
+a.text-success:hover,
+a.text-success:focus {
+  color: #356635;
+}
+.text-left {
+  text-align: left;
+}
+.text-right {
+  text-align: right;
+}
+.text-center {
+  text-align: center;
+}
+h1,
+h2,
+h3,
+h4,
+h5,
+h6 {
+  margin: 10px 0;
+  font-family: inherit;
+  font-weight: bold;
+  line-height: 20px;
+  color: inherit;
+  text-rendering: optimizelegibility;
+}
+h1 small,
+h2 small,
+h3 small,
+h4 small,
+h5 small,
+h6 small {
+  font-weight: normal;
+  line-height: 1;
+  color: #999999;
+}
+h1,
+h2,
+h3 {
+  line-height: 40px;
+}
+h1 {
+  font-size: 38.5px;
+}
+h2 {
+  font-size: 31.5px;
+}
+h3 {
+  font-size: 24.5px;
+}
+h4 {
+  font-size: 17.5px;
+}
+h5 {
+  font-size: 14px;
+}
+h6 {
+  font-size: 11.9px;
+}
+h1 small {
+  font-size: 24.5px;
+}
+h2 small {
+  font-size: 17.5px;
+}
+h3 small {
+  font-size: 14px;
+}
+h4 small {
+  font-size: 14px;
+}
+.page-header {
+  padding-bottom: 9px;
+  margin: 20px 0 30px;
+  border-bottom: 1px solid #eeeeee;
+}
+ul,
+ol {
+  padding: 0;
+  margin: 0 0 10px 25px;
+}
+ul ul,
+ul ol,
+ol ol,
+ol ul {
+  margin-bottom: 0;
+}
+li {
+  line-height: 20px;
+}
+ul.unstyled,
+ol.unstyled {
+  margin-left: 0;
+  list-style: none;
+}
+ul.inline,
+ol.inline {
+  margin-left: 0;
+  list-style: none;
+}
+ul.inline > li,
+ol.inline > li {
+  display: inline-block;
+  *display: inline;
+  /* IE7 inline-block hack */
+
+  *zoom: 1;
+  padding-left: 5px;
+  padding-right: 5px;
+}
+dl {
+  margin-bottom: 20px;
+}
+dt,
+dd {
+  line-height: 20px;
+}
+dt {
+  font-weight: bold;
+}
+dd {
+  margin-left: 10px;
+}
+.dl-horizontal {
+  *zoom: 1;
+}
+.dl-horizontal:before,
+.dl-horizontal:after {
+  display: table;
+  content: "";
+  line-height: 0;
+}
+.dl-horizontal:after {
+  clear: both;
+}
+.dl-horizontal dt {
+  float: left;
+  width: 160px;
+  clear: left;
+  text-align: right;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.dl-horizontal dd {
+  margin-left: 180px;
+}
+hr {
+  margin: 20px 0;
+  border: 0;
+  border-top: 1px solid #eeeeee;
+  border-bottom: 1px solid #ffffff;
+}
+abbr[title],
+abbr[data-original-title] {
+  cursor: help;
+  border-bottom: 1px dotted #999999;
+}
+abbr.initialism {
+  font-size: 90%;
+  text-transform: uppercase;
+}
+blockquote {
+  padding: 0 0 0 15px;
+  margin: 0 0 20px;
+  border-left: 5px solid #eeeeee;
+}
+blockquote p {
+  margin-bottom: 0;
+  font-size: 17.5px;
+  font-weight: 300;
+  line-height: 1.25;
+}
+blockquote small {
+  display: block;
+  line-height: 20px;
+  color: #999999;
+}
+blockquote small:before {
+  content: '\2014 \00A0';
+}
+blockquote.pull-right {
+  float: right;
+  padding-right: 15px;
+  padding-left: 0;
+  border-right: 5px solid #eeeeee;
+  border-left: 0;
+}
+blockquote.pull-right p,
+blockquote.pull-right small {
+  text-align: right;
+}
+blockquote.pull-right small:before {
+  content: '';
+}
+blockquote.pull-right small:after {
+  content: '\00A0 \2014';
+}
+q:before,
+q:after,
+blockquote:before,
+blockquote:after {
+  content: "";
+}
+address {
+  display: block;
+  margin-bottom: 20px;
+  font-style: normal;
+  line-height: 20px;
+}
+code,
+pre {
+  padding: 0 3px 2px;
+  font-family: Monaco, Menlo, Consolas, "Courier New", monospace;
+  font-size: 12px;
+  color: #333333;
+  -webkit-border-radius: 3px;
+  -moz-border-radius: 3px;
+  border-radius: 3px;
+}
+code {
+  padding: 2px 4px;
+  color: #d14;
+  background-color: #f7f7f9;
+  border: 1px solid #e1e1e8;
+  white-space: nowrap;
+}
+pre {
+  display: block;
+  padding: 9.5px;
+  margin: 0 0 10px;
+  font-size: 13px;
+  line-height: 20px;
+  word-break: break-all;
+  word-wrap: break-word;
+  white-space: pre;
+  white-space: pre-wrap;
+  background-color: #f5f5f5;
+  border: 1px solid #ccc;
+  border: 1px solid rgba(0, 0, 0, 0.15);
+  -webkit-border-radius: 4px;
+  -moz-border-radius: 4px;
+  border-radius: 4px;
+}
+pre.prettyprint {
+  margin-bottom: 20px;
+}
+pre code {
+  padding: 0;
+  color: inherit;
+  white-space: pre;
+  white-space: pre-wrap;
+  background-color: transparent;
+  border: 0;
+}
+.pre-scrollable {
+  max-height: 340px;
+  overflow-y: scroll;
+}
+.label,
+.badge {
+  display: inline-block;
+  padding: 2px 4px;
+  font-size: 11.844px;
+  font-weight: bold;
+  line-height: 14px;
+  color: #ffffff;
+  vertical-align: baseline;
+  white-space: nowrap;
+  text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
+  background-color: #999999;
+}
+.label {
+  -webkit-border-radius: 3px;
+  -moz-border-radius: 3px;
+  border-radius: 3px;
+}
+.badge {
+  padding-left: 9px;
+  padding-right: 9px;
+  -webkit-border-radius: 9px;
+  -moz-border-radius: 9px;
+  border-radius: 9px;
+}
+.label:empty,
+.badge:empty {
+  display: none;
+}
+a.label:hover,
+a.label:focus,
+a.badge:hover,
+a.badge:focus {
+  color: #ffffff;
+  text-decoration: none;
+  cursor: pointer;
+}
+.label-important,
+.badge-important {
+  background-color: #b94a48;
+}
+.label-important[href],
+.badge-important[href] {
+  background-color: #953b39;
+}
+.label-warning,
+.badge-warning {
+  background-color: #f89406;
+}
+.label-warning[href],
+.badge-warning[href] {
+  background-color: #c67605;
+}
+.label-success,
+.badge-success {
+  background-color: #468847;
+}
+.label-success[href],
+.badge-success[href] {
+  background-color: #356635;
+}
+.label-info,
+.badge-info {
+  background-color: #3a87ad;
+}
+.label-info[href],
+.badge-info[href] {
+  background-color: #2d6987;
+}
+.label-inverse,
+.badge-inverse {
+  background-color: #333333;
+}
+.label-inverse[href],
+.badge-inverse[href] {
+  background-color: #1a1a1a;
+}
+.btn .label,
+.btn .badge {
+  position: relative;
+  top: -1px;
+}
+.btn-mini .label,
+.btn-mini .badge {
+  top: 0;
+}
+table {
+  max-width: 100%;
+  background-color: transparent;
+  border-collapse: collapse;
+  border-spacing: 0;
+}
+.table {
+  width: 100%;
+  margin-bottom: 20px;
+}
+.table th,
+.table td {
+  padding: 8px;
+  line-height: 20px;
+  text-align: left;
+  vertical-align: top;
+  border-top: 1px solid #dddddd;
+}
+.table th {
+  font-weight: bold;
+}
+.table thead th {
+  vertical-align: bottom;
+}
+.table caption + thead tr:first-child th,
+.table caption + thead tr:first-child td,
+.table colgroup + thead tr:first-child th,
+.table colgroup + thead tr:first-child td,
+.table thead:first-child tr:first-child th,
+.table thead:first-child tr:first-child td {
+  border-top: 0;
+}
+.table tbody + tbody {
+  border-top: 2px solid #dddddd;
+}
+.table .table {
+  background-color: #ffffff;
+}
+.table-condensed th,
+.table-condensed td {
+  padding: 4px 5px;
+}
+.table-bordered {
+  border: 1px solid #dddddd;
+  border-collapse: separate;
+  *border-collapse: collapse;
+  border-left: 0;
+  -webkit-border-radius: 4px;
+  -moz-border-radius: 4px;
+  border-radius: 4px;
+}
+.table-bordered th,
+.table-bordered td {
+  border-left: 1px solid #dddddd;
+}
+.table-bordered caption + thead tr:first-child th,
+.table-bordered caption + tbody tr:first-child th,
+.table-bordered caption + tbody tr:first-child td,
+.table-bordered colgroup + thead tr:first-child th,
+.table-bordered colgroup + tbody tr:first-child th,
+.table-bordered colgroup + tbody tr:first-child td,
+.table-bordered thead:first-child tr:first-child th,
+.table-bordered tbody:first-child tr:first-child th,
+.table-bordered tbody:first-child tr:first-child td {
+  border-top: 0;
+}
+.table-bordered thead:first-child tr:first-child > th:first-child,
+.table-bordered tbody:first-child tr:first-child > td:first-child,
+.table-bordered tbody:first-child tr:first-child > th:first-child {
+  -webkit-border-top-left-radius: 4px;
+  -moz-border-radius-topleft: 4px;
+  border-top-left-radius: 4px;
+}
+.table-bordered thead:first-child tr:first-child > th:last-child,
+.table-bordered tbody:first-child tr:first-child > td:last-child,
+.table-bordered tbody:first-child tr:first-child > th:last-child {
+  -webkit-border-top-right-radius: 4px;
+  -moz-border-radius-topright: 4px;
+  border-top-right-radius: 4px;
+}
+.table-bordered thead:last-child tr:last-child > th:first-child,
+.table-bordered tbody:last-child tr:last-child > td:first-child,
+.table-bordered tbody:last-child tr:last-child > th:first-child,
+.table-bordered tfoot:last-child tr:last-child > td:first-child,
+.table-bordered tfoot:last-child tr:last-child > th:first-child {
+  -webkit-border-bottom-left-radius: 4px;
+  -moz-border-radius-bottomleft: 4px;
+  border-bottom-left-radius: 4px;
+}
+.table-bordered thead:last-child tr:last-child > th:last-child,
+.table-bordered tbody:last-child tr:last-child > td:last-child,
+.table-bordered tbody:last-child tr:last-child > th:last-child,
+.table-bordered tfoot:last-child tr:last-child > td:last-child,
+.table-bordered tfoot:last-child tr:last-child > th:last-child {
+  -webkit-border-bottom-right-radius: 4px;
+  -moz-border-radius-bottomright: 4px;
+  border-bottom-right-radius: 4px;
+}
+.table-bordered tfoot + tbody:last-child tr:last-child td:first-child {
+  -webkit-border-bottom-left-radius: 0;
+  -moz-border-radius-bottomleft: 0;
+  border-bottom-left-radius: 0;
+}
+.table-bordered tfoot + tbody:last-child tr:last-child td:last-child {
+  -webkit-border-bottom-right-radius: 0;
+  -moz-border-radius-bottomright: 0;
+  border-bottom-right-radius: 0;
+}
+.table-bordered caption + thead tr:first-child th:first-child,
+.table-bordered caption + tbody tr:first-child td:first-child,
+.table-bordered colgroup + thead tr:first-child th:first-child,
+.table-bordered colgroup + tbody tr:first-child td:first-child {
+  -webkit-border-top-left-radius: 4px;
+  -moz-border-radius-topleft: 4px;
+  border-top-left-radius: 4px;
+}
+.table-bordered caption + thead tr:first-child th:last-child,
+.table-bordered caption + tbody tr:first-child td:last-child,
+.table-bordered colgroup + thead tr:first-child th:last-child,
+.table-bordered colgroup + tbody tr:first-child td:last-child {
+  -webkit-border-top-right-radius: 4px;
+  -moz-border-radius-topright: 4px;
+  border-top-right-radius: 4px;
+}
+.table-striped tbody > tr:nth-child(odd) > td,
+.table-striped tbody > tr:nth-child(odd) > th {
+  background-color: #f9f9f9;
+}
+.table-hover tbody tr:hover > td,
+.table-hover tbody tr:hover > th {
+  background-color: #f5f5f5;
+}
+table td[class*="span"],
+table th[class*="span"],
+.row-fluid table td[class*="span"],
+.row-fluid table th[class*="span"] {
+  display: table-cell;
+  float: none;
+  margin-left: 0;
+}
+.table td.span1,
+.table th.span1 {
+  float: none;
+  width: 44px;
+  margin-left: 0;
+}
+.table td.span2,
+.table th.span2 {
+  float: none;
+  width: 124px;
+  margin-left: 0;
+}
+.table td.span3,
+.table th.span3 {
+  float: none;
+  width: 204px;
+  margin-left: 0;
+}
+.table td.span4,
+.table th.span4 {
+  float: none;
+  width: 284px;
+  margin-left: 0;
+}
+.table td.span5,
+.table th.span5 {
+  float: none;
+  width: 364px;
+  margin-left: 0;
+}
+.table td.span6,
+.table th.span6 {
+  float: none;
+  width: 444px;
+  margin-left: 0;
+}
+.table td.span7,
+.table th.span7 {
+  float: none;
+  width: 524px;
+  margin-left: 0;
+}
+.table td.span8,
+.table th.span8 {
+  float: none;
+  width: 604px;
+  margin-left: 0;
+}
+.table td.span9,
+.table th.span9 {
+  float: none;
+  width: 684px;
+  margin-left: 0;
+}
+.table td.span10,
+.table th.span10 {
+  float: none;
+  width: 764px;
+  margin-left: 0;
+}
+.table td.span11,
+.table th.span11 {
+  float: none;
+  width: 844px;
+  margin-left: 0;
+}
+.table td.span12,
+.table th.span12 {
+  float: none;
+  width: 924px;
+  margin-left: 0;
+}
+.table tbody tr.success > td {
+  background-color: #dff0d8;
+}
+.table tbody tr.error > td {
+  background-color: #f2dede;
+}
+.table tbody tr.warning > td {
+  background-color: #fcf8e3;
+}
+.table tbody tr.info > td {
+  background-color: #d9edf7;
+}
+.table-hover tbody tr.success:hover > td {
+  background-color: #d0e9c6;
+}
+.table-hover tbody tr.error:hover > td {
+  background-color: #ebcccc;
+}
+.table-hover tbody tr.warning:hover > td {
+  background-color: #faf2cc;
+}
+.table-hover tbody tr.info:hover > td {
+  background-color: #c4e3f3;
+}
+form {
+  margin: 0 0 20px;
+}
+fieldset {
+  padding: 0;
+  margin: 0;
+  border: 0;
+}
+legend {
+  display: block;
+  width: 100%;
+  padding: 0;
+  margin-bottom: 20px;
+  font-size: 21px;
+  line-height: 40px;
+  color: #333333;
+  border: 0;
+  border-bottom: 1px solid #e5e5e5;
+}
+legend small {
+  font-size: 15px;
+  color: #999999;
+}
+label,
+input,
+button,
+select,
+textarea {
+  font-size: 14px;
+  font-weight: normal;
+  line-height: 20px;
+}
+input,
+button,
+select,
+textarea {
+  font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+}
+label {
+  display: block;
+  margin-bottom: 5px;
+}
+select,
+textarea,
+input[type="text"],
+input[type="password"],
+input[type="datetime"],
+input[type="datetime-local"],
+input[type="date"],
+input[type="month"],
+input[type="time"],
+input[type="week"],
+input[type="number"],
+input[type="email"],
+input[type="url"],
+input[type="search"],
+input[type="tel"],
+input[type="color"],
+.uneditable-input {
+  display: inline-block;
+  height: 20px;
+  padding: 4px 6px;
+  margin-bottom: 10px;
+  font-size: 14px;
+  line-height: 20px;
+  color: #555555;
+  -webkit-border-radius: 4px;
+  -moz-border-radius: 4px;
+  border-radius: 4px;
+  vertical-align: middle;
+}
+input,
+textarea,
+.uneditable-input {
+  width: 206px;
+}
+textarea {
+  height: auto;
+}
+textarea,
+input[type="text"],
+input[type="password"],
+input[type="datetime"],
+input[type="datetime-local"],
+input[type="date"],
+input[type="month"],
+input[type="time"],
+input[type="week"],
+input[type="number"],
+input[type="email"],
+input[type="url"],
+input[type="search"],
+input[type="tel"],
+input[type="color"],
+.uneditable-input {
+  background-color: #ffffff;
+  border: 1px solid #cccccc;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+  -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+  box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+  -webkit-transition: border linear .2s, box-shadow linear .2s;
+  -moz-transition: border linear .2s, box-shadow linear .2s;
+  -o-transition: border linear .2s, box-shadow linear .2s;
+  transition: border linear .2s, box-shadow linear .2s;
+}
+textarea:focus,
+input[type="text"]:focus,
+input[type="password"]:focus,
+input[type="datetime"]:focus,
+input[type="datetime-local"]:focus,
+input[type="date"]:focus,
+input[type="month"]:focus,
+input[type="time"]:focus,
+input[type="week"]:focus,
+input[type="number"]:focus,
+input[type="email"]:focus,
+input[type="url"]:focus,
+input[type="search"]:focus,
+input[type="tel"]:focus,
+input[type="color"]:focus,
+.uneditable-input:focus {
+  border-color: rgba(82, 168, 236, 0.8);
+  outline: 0;
+  outline: thin dotted \9;
+  /* IE6-9 */
+
+  -webkit-box-shadow: inset 0 1px 1px rgba(0,0,0,.075), 0 0 8px rgba(82,168,236,.6);
+  -moz-box-shadow: inset 0 1px 1px rgba(0,0,0,.075), 0 0 8px rgba(82,168,236,.6);
+  box-shadow: inset 0 1px 1px rgba(0,0,0,.075), 0 0 8px rgba(82,168,236,.6);
+}
+input[type="radio"],
+input[type="checkbox"] {
+  margin: 4px 0 0;
+  *margin-top: 0;
+  /* IE7 */
+
+  margin-top: 1px \9;
+  /* IE8-9 */
+
+  line-height: normal;
+}
+input[type="file"],
+input[type="image"],
+input[type="submit"],
+input[type="reset"],
+input[type="button"],
+input[type="radio"],
+input[type="checkbox"] {
+  width: auto;
+}
+select,
+input[type="file"] {
+  height: 30px;
+  /* In IE7, the height of the select element cannot be changed by height, only font-size */
+
+  *margin-top: 4px;
+  /* For IE7, add top margin to align select with labels */
+
+  line-height: 30px;
+}
+select {
+  width: 220px;
+  border: 1px solid #cccccc;
+  background-color: #ffffff;
+}
+select[multiple],
+select[size] {
+  height: auto;
+}
+select:focus,
+input[type="file"]:focus,
+input[type="radio"]:focus,
+input[type="checkbox"]:focus {
+  outline: thin dotted #333;
+  outline: 5px auto -webkit-focus-ring-color;
+  outline-offset: -2px;
+}
+.uneditable-input,
+.uneditable-textarea {
+  color: #999999;
+  background-color: #fcfcfc;
+  border-color: #cccccc;
+  -webkit-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.025);
+  -moz-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.025);
+  box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.025);
+  cursor: not-allowed;
+}
+.uneditable-input {
+  overflow: hidden;
+  white-space: nowrap;
+}
+.uneditable-textarea {
+  width: auto;
+  height: auto;
+}
+input:-moz-placeholder,
+textarea:-moz-placeholder {
+  color: #999999;
+}
+input:-ms-input-placeholder,
+textarea:-ms-input-placeholder {
+  color: #999999;
+}
+input::-webkit-input-placeholder,
+textarea::-webkit-input-placeholder {
+  color: #999999;
+}
+.radio,
+.checkbox {
+  min-height: 20px;
+  padding-left: 20px;
+}
+.radio input[type="radio"],
+.checkbox input[type="checkbox"] {
+  float: left;
+  margin-left: -20px;
+}
+.controls > .radio:first-child,
+.controls > .checkbox:first-child {
+  padding-top: 5px;
+}
+.radio.inline,
+.checkbox.inline {
+  display: inline-block;
+  padding-top: 5px;
+  margin-bottom: 0;
+  vertical-align: middle;
+}
+.radio.inline + .radio.inline,
+.checkbox.inline + .checkbox.inline {
+  margin-left: 10px;
+}
+.input-mini {
+  width: 60px;
+}
+.input-small {
+  width: 90px;
+}
+.input-medium {
+  width: 150px;
+}
+.input-large {
+  width: 210px;
+}
+.input-xlarge {
+  width: 270px;
+}
+.input-xxlarge {
+  width: 530px;
+}
+input[class*="span"],
+select[class*="span"],
+textarea[class*="span"],
+.uneditable-input[class*="span"],
+.row-fluid input[class*="span"],
+.row-fluid select[class*="span"],
+.row-fluid textarea[class*="span"],
+.row-fluid .uneditable-input[class*="span"] {
+  float: none;
+  margin-left: 0;
+}
+.input-append input[class*="span"],
+.input-append .uneditable-input[class*="span"],
+.input-prepend input[class*="span"],
+.input-prepend .uneditable-input[class*="span"],
+.row-fluid input[class*="span"],
+.row-fluid select[class*="span"],
+.row-fluid textarea[class*="span"],
+.row-fluid .uneditable-input[class*="span"],
+.row-fluid .input-prepend [class*="span"],
+.row-fluid .input-append [class*="span"] {
+  display: inline-block;
+}
+input,
+textarea,
+.uneditable-input {
+  margin-left: 0;
+}
+.controls-row [class*="span"] + [class*="span"] {
+  margin-left: 20px;
+}
+input.span12,
+textarea.span12,
+.uneditable-input.span12 {
+  width: 926px;
+}
+input.span11,
+textarea.span11,
+.uneditable-input.span11 {
+  width: 846px;
+}
+input.span10,
+textarea.span10,
+.uneditable-input.span10 {
+  width: 766px;
+}
+input.span9,
+textarea.span9,
+.uneditable-input.span9 {
+  width: 686px;
+}
+input.span8,
+textarea.span8,
+.uneditable-input.span8 {
+  width: 606px;
+}
+input.span7,
+textarea.span7,
+.uneditable-input.span7 {
+  width: 526px;
+}
+input.span6,
+textarea.span6,
+.uneditable-input.span6 {
+  width: 446px;
+}
+input.span5,
+textarea.span5,
+.uneditable-input.span5 {
+  width: 366px;
+}
+input.span4,
+textarea.span4,
+.uneditable-input.span4 {
+  width: 286px;
+}
+input.span3,
+textarea.span3,
+.uneditable-input.span3 {
+  width: 206px;
+}
+input.span2,
+textarea.span2,
+.uneditable-input.span2 {
+  width: 126px;
+}
+input.span1,
+textarea.span1,
+.uneditable-input.span1 {
+  width: 46px;
+}
+.controls-row {
+  *zoom: 1;
+}
+.controls-row:before,
+.controls-row:after {
+  display: table;
+  content: "";
+  line-height: 0;
+}
+.controls-row:after {
+  clear: both;
+}
+.controls-row [class*="span"],
+.row-fluid .controls-row [class*="span"] {
+  float: left;
+}
+.controls-row .checkbox[class*="span"],
+.controls-row .radio[class*="span"] {
+  padding-top: 5px;
+}
+input[disabled],
+select[disabled],
+textarea[disabled],
+input[readonly],
+select[readonly],
+textarea[readonly] {
+  cursor: not-allowed;
+  background-color: #eeeeee;
+}
+input[type="radio"][disabled],
+input[type="checkbox"][disabled],
+input[type="radio"][readonly],
+input[type="checkbox"][readonly] {
+  background-color: transparent;
+}
+.control-group.warning .control-label,
+.control-group.warning .help-block,
+.control-group.warning .help-inline {
+  color: #c09853;
+}
+.control-group.warning .checkbox,
+.control-group.warning .radio,
+.control-group.warning input,
+.control-group.warning select,
+.control-group.warning textarea {
+  color: #c09853;
+}
+.control-group.warning input,
+.control-group.warning select,
+.control-group.warning textarea {
+  border-color: #c09853;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+  -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+  box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+}
+.control-group.warning input:focus,
+.control-group.warning select:focus,
+.control-group.warning textarea:focus {
+  border-color: #a47e3c;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #dbc59e;
+  -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #dbc59e;
+  box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #dbc59e;
+}
+.control-group.warning .input-prepend .add-on,
+.control-group.warning .input-append .add-on {
+  color: #c09853;
+  background-color: #fcf8e3;
+  border-color: #c09853;
+}
+.control-group.error .control-label,
+.control-group.error .help-block,
+.control-group.error .help-inline {
+  color: #b94a48;
+}
+.control-group.error .checkbox,
+.control-group.error .radio,
+.control-group.error input,
+.control-group.error select,
+.control-group.error textarea {
+  color: #b94a48;
+}
+.control-group.error input,
+.control-group.error select,
+.control-group.error textarea {
+  border-color: #b94a48;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+  -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+  box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+}
+.control-group.error input:focus,
+.control-group.error select:focus,
+.control-group.error textarea:focus {
+  border-color: #953b39;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #d59392;
+  -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #d59392;
+  box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #d59392;
+}
+.control-group.error .input-prepend .add-on,
+.control-group.error .input-append .add-on {
+  color: #b94a48;
+  background-color: #f2dede;
+  border-color: #b94a48;
+}
+.control-group.success .control-label,
+.control-group.success .help-block,
+.control-group.success .help-inline {
+  color: #468847;
+}
+.control-group.success .checkbox,
+.control-group.success .radio,
+.control-group.success input,
+.control-group.success select,
+.control-group.success textarea {
+  color: #468847;
+}
+.control-group.success input,
+.control-group.success select,
+.control-group.success textarea {
+  border-color: #468847;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+  -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+  box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+}
+.control-group.success input:focus,
+.control-group.success select:focus,
+.control-group.success textarea:focus {
+  border-color: #356635;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #7aba7b;
+  -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #7aba7b;
+  box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #7aba7b;
+}
+.control-group.success .input-prepend .add-on,
+.control-group.success .input-append .add-on {
+  color: #468847;
+  background-color: #dff0d8;
+  border-color: #468847;
+}
+.control-group.info .control-label,
+.control-group.info .help-block,
+.control-group.info .help-inline {
+  color: #3a87ad;
+}
+.control-group.info .checkbox,
+.control-group.info .radio,
+.control-group.info input,
+.control-group.info select,
+.control-group.info textarea {
+  color: #3a87ad;
+}
+.control-group.info input,
+.control-group.info select,
+.control-group.info textarea {
+  border-color: #3a87ad;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+  -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+  box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+}
+.control-group.info input:focus,
+.control-group.info select:focus,
+.control-group.info textarea:focus {
+  border-color: #2d6987;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #7ab5d3;
+  -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #7ab5d3;
+  box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #7ab5d3;
+}
+.control-group.info .input-prepend .add-on,
+.control-group.info .input-append .add-on {
+  color: #3a87ad;
+  background-color: #d9edf7;
+  border-color: #3a87ad;
+}
+input:focus:invalid,
+textarea:focus:invalid,
+select:focus:invalid {
+  color: #b94a48;
+  border-color: #ee5f5b;
+}
+input:focus:invalid:focus,
+textarea:focus:invalid:focus,
+select:focus:invalid:focus {
+  border-color: #e9322d;
+  -webkit-box-shadow: 0 0 6px #f8b9b7;
+  -moz-box-shadow: 0 0 6px #f8b9b7;
+  box-shadow: 0 0 6px #f8b9b7;
+}
+.form-actions {
+  padding: 19px 20px 20px;
+  margin-top: 20px;
+  margin-bottom: 20px;
+  background-color: #f5f5f5;
+  border-top: 1px solid #e5e5e5;
+  *zoom: 1;
+}
+.form-actions:before,
+.form-actions:after {
+  display: table;
+  content: "";
+  line-height: 0;
+}
+.form-actions:after {
+  clear: both;
+}
+.help-block,
+.help-inline {
+  color: #595959;
+}
+.help-block {
+  display: block;
+  margin-bottom: 10px;
+}
+.help-inline {
+  display: inline-block;
+  *display: inline;
+  /* IE7 inline-block hack */
+
+  *zoom: 1;
+  vertical-align: middle;
+  padding-left: 5px;
+}
+.input-append,
+.input-prepend {
+  display: inline-block;
+  margin-bottom: 10px;
+  vertical-align: middle;
+  font-size: 0;
+  white-space: nowrap;
+}
+.input-append input,
+.input-prepend input,
+.input-append select,
+.input-prepend select,
+.input-append .uneditable-input,
+.input-prepend .uneditable-input,
+.input-append .dropdown-menu,
+.input-prepend .dropdown-menu,
+.input-append .popover,
+.input-prepend .popover {
+  font-size: 14px;
+}
+.input-append input,
+.input-prepend input,
+.input-append select,
+.input-prepend select,
+.input-append .uneditable-input,
+.input-prepend .uneditable-input {
+  position: relative;
+  margin-bottom: 0;
+  *margin-left: 0;
+  vertical-align: top;
+  -webkit-border-radius: 0 4px 4px 0;
+  -moz-border-radius: 0 4px 4px 0;
+  border-radius: 0 4px 4px 0;
+}
+.input-append input:focus,
+.input-prepend input:focus,
+.input-append select:focus,
+.input-prepend select:focus,
+.input-append .uneditable-input:focus,
+.input-prepend .uneditable-input:focus {
+  z-index: 2;
+}
+.input-append .add-on,
+.input-prepend .add-on {
+  display: inline-block;
+  width: auto;
+  height: 20px;
+  min-width: 16px;
+  padding: 4px 5px;
+  font-size: 14px;
+  font-weight: normal;
+  line-height: 20px;
+  text-align: center;
+  text-shadow: 0 1px 0 #ffffff;
+  background-color: #eeeeee;
+  border: 1px solid #ccc;
+}
+.input-append .add-on,
+.input-prepend .add-on,
+.input-append .btn,
+.input-prepend .btn,
+.input-append .btn-group > .dropdown-toggle,
+.input-prepend .btn-group > .dropdown-toggle {
+  vertical-align: top;
+  -webkit-border-radius: 0;
+  -moz-border-radius: 0;
+  border-radius: 0;
+}
+.input-append .active,
+.input-prepend .active {
+  background-color: #a9dba9;
+  border-color: #46a546;
+}
+.input-prepend .add-on,
+.input-prepend .btn {
+  margin-right: -1px;
+}
+.input-prepend .add-on:first-child,
+.input-prepend .btn:first-child {
+  -webkit-border-radius: 4px 0 0 4px;
+  -moz-border-radius: 4px 0 0 4px;
+  border-radius: 4px 0 0 4px;
+}
+.input-append input,
+.input-append select,
+.input-append .uneditable-input {
+  -webkit-border-radius: 4px 0 0 4px;
+  -moz-border-radius: 4px 0 0 4px;
+  border-radius: 4px 0 0 4px;
+}
+.input-append input + .btn-group .btn:last-child,
+.input-append select + .btn-group .btn:last-child,
+.input-append .uneditable-input + .btn-group .btn:last-child {
+  -webkit-border-radius: 0 4px 4px 0;
+  -moz-border-radius: 0 4px 4px 0;
+  border-radius: 0 4px 4px 0;
+}
+.input-append .add-on,
+.input-append .btn,
+.input-append .btn-group {
+  margin-left: -1px;
+}
+.input-append .add-on:last-child,
+.input-append .btn:last-child,
+.input-append .btn-group:last-child > .dropdown-toggle {
+  -webkit-border-radius: 0 4px 4px 0;
+  -moz-border-radius: 0 4px 4px 0;
+  border-radius: 0 4px 4px 0;
+}
+.input-prepend.input-append input,
+.input-prepend.input-append select,
+.input-prepend.input-append .uneditable-input {
+  -webkit-border-radius: 0;
+  -moz-border-radius: 0;
+  border-radius: 0;
+}
+.input-prepend.input-append input + .btn-group .btn,
+.input-prepend.input-append select + .btn-group .btn,
+.input-prepend.input-append .uneditable-input + .btn-group .btn {
+  -webkit-border-radius: 0 4px 4px 0;
+  -moz-border-radius: 0 4px 4px 0;
+  border-radius: 0 4px 4px 0;
+}
+.input-prepend.input-append .add-on:first-child,
+.input-prepend.input-append .btn:first-child {
+  margin-right: -1px;
+  -webkit-border-radius: 4px 0 0 4px;
+  -moz-border-radius: 4px 0 0 4px;
+  border-radius: 4px 0 0 4px;
+}
+.input-prepend.input-append .add-on:last-child,
+.input-prepend.input-append .btn:last-child {
+  margin-left: -1px;
+  -webkit-border-radius: 0 4px 4px 0;
+  -moz-border-radius: 0 4px 4px 0;
+  border-radius: 0 4px 4px 0;
+}
+.input-prepend.input-append .btn-group:first-child {
+  margin-left: 0;
+}
+input.search-query {
+  padding-right: 14px;
+  padding-right: 4px \9;
+  padding-left: 14px;
+  padding-left: 4px \9;
+  /* IE7-8 doesn't have border-radius, so don't indent the padding */
+
+  margin-bottom: 0;
+  -webkit-border-radius: 15px;
+  -moz-border-radius: 15px;
+  border-radius: 15px;
+}
+/* Allow for input prepend/append in search forms */
+.form-search .input-append .search-query,
+.form-search .input-prepend .search-query {
+  -webkit-border-radius: 0;
+  -moz-border-radius: 0;
+  border-radius: 0;
+}
+.form-search .input-append .search-query {
+  -webkit-border-radius: 14px 0 0 14px;
+  -moz-border-radius: 14px 0 0 14px;
+  border-radius: 14px 0 0 14px;
+}
+.form-search .input-append .btn {
+  -webkit-border-radius: 0 14px 14px 0;
+  -moz-border-radius: 0 14px 14px 0;
+  border-radius: 0 14px 14px 0;
+}
+.form-search .input-prepend .search-query {
+  -webkit-border-radius: 0 14px 14px 0;
+  -moz-border-radius: 0 14px 14px 0;
+  border-radius: 0 14px 14px 0;
+}
+.form-search .input-prepend .btn {
+  -webkit-border-radius: 14px 0 0 14px;
+  -moz-border-radius: 14px 0 0 14px;
+  border-radius: 14px 0 0 14px;
+}
+.form-search input,
+.form-inline input,
+.form-horizontal input,
+.form-search textarea,
+.form-inline textarea,
+.form-horizontal textarea,
+.form-search select,
+.form-inline select,
+.form-horizontal select,
+.form-search .help-inline,
+.form-inline .help-inline,
+.form-horizontal .help-inline,
+.form-search .uneditable-input,
+.form-inline .uneditable-input,
+.form-horizontal .uneditable-input,
+.form-search .input-prepend,
+.form-inline .input-prepend,
+.form-horizontal .input-prepend,
+.form-search .input-append,
+.form-inline .input-append,
+.form-horizontal .input-append {
+  display: inline-block;
+  *display: inline;
+  /* IE7 inline-block hack */
+
+  *zoom: 1;
+  margin-bottom: 0;
+  vertical-align: middle;
+}
+.form-search .hide,
+.form-inline .hide,
+.form-horizontal .hide {
+  display: none;
+}
+.form-search label,
+.form-inline label,
+.form-search .btn-group,
+.form-inline .btn-group {
+  display: inline-block;
+}
+.form-search .input-append,
+.form-inline .input-append,
+.form-search .input-prepend,
+.form-inline .input-prepend {
+  margin-bottom: 0;
+}
+.form-search .radio,
+.form-search .checkbox,
+.form-inline .radio,
+.form-inline .checkbox {
+  padding-left: 0;
+  margin-bottom: 0;
+  vertical-align: middle;
+}
+.form-search .radio input[type="radio"],
+.form-search .checkbox input[type="checkbox"],
+.form-inline .radio input[type="radio"],
+.form-inline .checkbox input[type="checkbox"] {
+  float: left;
+  margin-right: 3px;
+  margin-left: 0;
+}
+.control-group {
+  margin-bottom: 10px;
+}
+legend + .control-group {
+  margin-top: 20px;
+  -webkit-margin-top-collapse: separate;
+}
+.form-horizontal .control-group {
+  margin-bottom: 20px;
+  *zoom: 1;
+}
+.form-horizontal .control-group:before,
+.form-horizontal .control-group:after {
+  display: table;
+  content: "";
+  line-height: 0;
+}
+.form-horizontal .control-group:after {
+  clear: both;
+}
+.form-horizontal .control-label {
+  float: left;
+  width: 160px;
+  padding-top: 5px;
+  text-align: right;
+}
+.form-horizontal .controls {
+  *display: inline-block;
+  *padding-left: 20px;
+  margin-left: 180px;
+  *margin-left: 0;
+}
+.form-horizontal .controls:first-child {
+  *padding-left: 180px;
+}
+.form-horizontal .help-block {
+  margin-bottom: 0;
+}
+.form-horizontal input + .help-block,
+.form-horizontal select + .help-block,
+.form-horizontal textarea + .help-block,
+.form-horizontal .uneditable-input + .help-block,
+.form-horizontal .input-prepend + .help-block,
+.form-horizontal .input-append + .help-block {
+  margin-top: 10px;
+}
+.form-horizontal .form-actions {
+  padding-left: 180px;
+}
+.btn {
+  display: inline-block;
+  *display: inline;
+  /* IE7 inline-block hack */
+
+  *zoom: 1;
+  padding: 4px 12px;
+  margin-bottom: 0;
+  font-size: 14px;
+  line-height: 20px;
+  text-align: center;
+  vertical-align: middle;
+  cursor: pointer;
+  color: #333333;
+  text-shadow: 0 1px 1px rgba(255, 255, 255, 0.75);
+  background-color: #f5f5f5;
+  background-image: -moz-linear-gradient(top, #ffffff, #e6e6e6);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#ffffff), to(#e6e6e6));
+  background-image: -webkit-linear-gradient(top, #ffffff, #e6e6e6);
+  background-image: -o-linear-gradient(top, #ffffff, #e6e6e6);
+  background-image: linear-gradient(to bottom, #ffffff, #e6e6e6);
+  background-repeat: repeat-x;
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffffffff', endColorstr='#ffe6e6e6', GradientType=0);
+  border-color: #e6e6e6 #e6e6e6 #bfbfbf;
+  border-color: rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);
+  *background-color: #e6e6e6;
+  /* Darken IE7 buttons by default so they stand out more given they won't have borders */
+
+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
+  border: 1px solid #cccccc;
+  *border: 0;
+  border-bottom-color: #b3b3b3;
+  -webkit-border-radius: 4px;
+  -moz-border-radius: 4px;
+  border-radius: 4px;
+  *margin-left: .3em;
+  -webkit-box-shadow: inset 0 1px 0 rgba(255,255,255,.2), 0 1px 2px rgba(0,0,0,.05);
+  -moz-box-shadow: inset 0 1px 0 rgba(255,255,255,.2), 0 1px 2px rgba(0,0,0,.05);
+  box-shadow: inset 0 1px 0 rgba(255,255,255,.2), 0 1px 2px rgba(0,0,0,.05);
+}
+.btn:hover,
+.btn:focus,
+.btn:active,
+.btn.active,
+.btn.disabled,
+.btn[disabled] {
+  color: #333333;
+  background-color: #e6e6e6;
+  *background-color: #d9d9d9;
+}
+.btn:active,
+.btn.active {
+  background-color: #cccccc \9;
+}
+.btn:first-child {
+  *margin-left: 0;
+}
+.btn:hover,
+.btn:focus {
+  color: #333333;
+  text-decoration: none;
+  background-position: 0 -15px;
+  -webkit-transition: background-position 0.1s linear;
+  -moz-transition: background-position 0.1s linear;
+  -o-transition: background-position 0.1s linear;
+  transition: background-position 0.1s linear;
+}
+.btn:focus {
+  outline: thin dotted #333;
+  outline: 5px auto -webkit-focus-ring-color;
+  outline-offset: -2px;
+}
+.btn.active,
+.btn:active {
+  background-image: none;
+  outline: 0;
+  -webkit-box-shadow: inset 0 2px 4px rgba(0,0,0,.15), 0 1px 2px rgba(0,0,0,.05);
+  -moz-box-shadow: inset 0 2px 4px rgba(0,0,0,.15), 0 1px 2px rgba(0,0,0,.05);
+  box-shadow: inset 0 2px 4px rgba(0,0,0,.15), 0 1px 2px rgba(0,0,0,.05);
+}
+.btn.disabled,
+.btn[disabled] {
+  cursor: default;
+  background-image: none;
+  opacity: 0.65;
+  filter: alpha(opacity=65);
+  -webkit-box-shadow: none;
+  -moz-box-shadow: none;
+  box-shadow: none;
+}
+.btn-large {
+  padding: 11px 19px;
+  font-size: 17.5px;
+  -webkit-border-radius: 6px;
+  -moz-border-radius: 6px;
+  border-radius: 6px;
+}
+.btn-large [class^="icon-"],
+.btn-large [class*=" icon-"] {
+  margin-top: 4px;
+}
+.btn-small {
+  padding: 2px 10px;
+  font-size: 11.9px;
+  -webkit-border-radius: 3px;
+  -moz-border-radius: 3px;
+  border-radius: 3px;
+}
+.btn-small [class^="icon-"],
+.btn-small [class*=" icon-"] {
+  margin-top: 0;
+}
+.btn-mini [class^="icon-"],
+.btn-mini [class*=" icon-"] {
+  margin-top: -1px;
+}
+.btn-mini {
+  padding: 0 6px;
+  font-size: 10.5px;
+  -webkit-border-radius: 3px;
+  -moz-border-radius: 3px;
+  border-radius: 3px;
+}
+.btn-block {
+  display: block;
+  width: 100%;
+  padding-left: 0;
+  padding-right: 0;
+  -webkit-box-sizing: border-box;
+  -moz-box-sizing: border-box;
+  box-sizing: border-box;
+}
+.btn-block + .btn-block {
+  margin-top: 5px;
+}
+input[type="submit"].btn-block,
+input[type="reset"].btn-block,
+input[type="button"].btn-block {
+  width: 100%;
+}
+.btn-primary.active,
+.btn-warning.active,
+.btn-danger.active,
+.btn-success.active,
+.btn-info.active,
+.btn-inverse.active {
+  color: rgba(255, 255, 255, 0.75);
+}
+.btn-primary {
+  color: #ffffff;
+  text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
+  background-color: #006dcc;
+  background-image: -moz-linear-gradient(top, #0088cc, #0044cc);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#0088cc), to(#0044cc));
+  background-image: -webkit-linear-gradient(top, #0088cc, #0044cc);
+  background-image: -o-linear-gradient(top, #0088cc, #0044cc);
+  background-image: linear-gradient(to bottom, #0088cc, #0044cc);
+  background-repeat: repeat-x;
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff0088cc', endColorstr='#ff0044cc', GradientType=0);
+  border-color: #0044cc #0044cc #002a80;
+  border-color: rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);
+  *background-color: #0044cc;
+  /* Darken IE7 buttons by default so they stand out more given they won't have borders */
+
+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
+}
+.btn-primary:hover,
+.btn-primary:focus,
+.btn-primary:active,
+.btn-primary.active,
+.btn-primary.disabled,
+.btn-primary[disabled] {
+  color: #ffffff;
+  background-color: #0044cc;
+  *background-color: #003bb3;
+}
+.btn-primary:active,
+.btn-primary.active {
+  background-color: #003399 \9;
+}
+.btn-warning {
+  color: #ffffff;
+  text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
+  background-color: #faa732;
+  background-image: -moz-linear-gradient(top, #fbb450, #f89406);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#fbb450), to(#f89406));
+  background-image: -webkit-linear-gradient(top, #fbb450, #f89406);
+  background-image: -o-linear-gradient(top, #fbb450, #f89406);
+  background-image: linear-gradient(to bottom, #fbb450, #f89406);
+  background-repeat: repeat-x;
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fffbb450', endColorstr='#fff89406', GradientType=0);
+  border-color: #f89406 #f89406 #ad6704;
+  border-color: rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);
+  *background-color: #f89406;
+  /* Darken IE7 buttons by default so they stand out more given they won't have borders */
+
+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
+}
+.btn-warning:hover,
+.btn-warning:focus,
+.btn-warning:active,
+.btn-warning.active,
+.btn-warning.disabled,
+.btn-warning[disabled] {
+  color: #ffffff;
+  background-color: #f89406;
+  *background-color: #df8505;
+}
+.btn-warning:active,
+.btn-warning.active {
+  background-color: #c67605 \9;
+}
+.btn-danger {
+  color: #ffffff;
+  text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
+  background-color: #da4f49;
+  background-image: -moz-linear-gradient(top, #ee5f5b, #bd362f);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#ee5f5b), to(#bd362f));
+  background-image: -webkit-linear-gradient(top, #ee5f5b, #bd362f);
+  background-image: -o-linear-gradient(top, #ee5f5b, #bd362f);
+  background-image: linear-gradient(to bottom, #ee5f5b, #bd362f);
+  background-repeat: repeat-x;
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffee5f5b', endColorstr='#ffbd362f', GradientType=0);
+  border-color: #bd362f #bd362f #802420;
+  border-color: rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);
+  *background-color: #bd362f;
+  /* Darken IE7 buttons by default so they stand out more given they won't have borders */
+
+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
+}
+.btn-danger:hover,
+.btn-danger:focus,
+.btn-danger:active,
+.btn-danger.active,
+.btn-danger.disabled,
+.btn-danger[disabled] {
+  color: #ffffff;
+  background-color: #bd362f;
+  *background-color: #a9302a;
+}
+.btn-danger:active,
+.btn-danger.active {
+  background-color: #942a25 \9;
+}
+.btn-success {
+  color: #ffffff;
+  text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
+  background-color: #5bb75b;
+  background-image: -moz-linear-gradient(top, #62c462, #51a351);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#62c462), to(#51a351));
+  background-image: -webkit-linear-gradient(top, #62c462, #51a351);
+  background-image: -o-linear-gradient(top, #62c462, #51a351);
+  background-image: linear-gradient(to bottom, #62c462, #51a351);
+  background-repeat: repeat-x;
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff62c462', endColorstr='#ff51a351', GradientType=0);
+  border-color: #51a351 #51a351 #387038;
+  border-color: rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);
+  *background-color: #51a351;
+  /* Darken IE7 buttons by default so they stand out more given they won't have borders */
+
+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
+}
+.btn-success:hover,
+.btn-success:focus,
+.btn-success:active,
+.btn-success.active,
+.btn-success.disabled,
+.btn-success[disabled] {
+  color: #ffffff;
+  background-color: #51a351;
+  *background-color: #499249;
+}
+.btn-success:active,
+.btn-success.active {
+  background-color: #408140 \9;
+}
+.btn-info {
+  color: #ffffff;
+  text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
+  background-color: #49afcd;
+  background-image: -moz-linear-gradient(top, #5bc0de, #2f96b4);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#5bc0de), to(#2f96b4));
+  background-image: -webkit-linear-gradient(top, #5bc0de, #2f96b4);
+  background-image: -o-linear-gradient(top, #5bc0de, #2f96b4);
+  background-image: linear-gradient(to bottom, #5bc0de, #2f96b4);
+  background-repeat: repeat-x;
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff5bc0de', endColorstr='#ff2f96b4', GradientType=0);
+  border-color: #2f96b4 #2f96b4 #1f6377;
+  border-color: rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);
+  *background-color: #2f96b4;
+  /* Darken IE7 buttons by default so they stand out more given they won't have borders */
+
+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
+}
+.btn-info:hover,
+.btn-info:focus,
+.btn-info:active,
+.btn-info.active,
+.btn-info.disabled,
+.btn-info[disabled] {
+  color: #ffffff;
+  background-color: #2f96b4;
+  *background-color: #2a85a0;
+}
+.btn-info:active,
+.btn-info.active {
+  background-color: #24748c \9;
+}
+.btn-inverse {
+  color: #ffffff;
+  text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
+  background-color: #363636;
+  background-image: -moz-linear-gradient(top, #444444, #222222);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#444444), to(#222222));
+  background-image: -webkit-linear-gradient(top, #444444, #222222);
+  background-image: -o-linear-gradient(top, #444444, #222222);
+  background-image: linear-gradient(to bottom, #444444, #222222);
+  background-repeat: repeat-x;
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff444444', endColorstr='#ff222222', GradientType=0);
+  border-color: #222222 #222222 #000000;
+  border-color: rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);
+  *background-color: #222222;
+  /* Darken IE7 buttons by default so they stand out more given they won't have borders */
+
+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
+}
+.btn-inverse:hover,
+.btn-inverse:focus,
+.btn-inverse:active,
+.btn-inverse.active,
+.btn-inverse.disabled,
+.btn-inverse[disabled] {
+  color: #ffffff;
+  background-color: #222222;
+  *background-color: #151515;
+}
+.btn-inverse:active,
+.btn-inverse.active {
+  background-color: #080808 \9;
+}
+button.btn,
+input[type="submit"].btn {
+  *padding-top: 3px;
+  *padding-bottom: 3px;
+}
+button.btn::-moz-focus-inner,
+input[type="submit"].btn::-moz-focus-inner {
+  padding: 0;
+  border: 0;
+}
+button.btn.btn-large,
+input[type="submit"].btn.btn-large {
+  *padding-top: 7px;
+  *padding-bottom: 7px;
+}
+button.btn.btn-small,
+input[type="submit"].btn.btn-small {
+  *padding-top: 3px;
+  *padding-bottom: 3px;
+}
+button.btn.btn-mini,
+input[type="submit"].btn.btn-mini {
+  *padding-top: 1px;
+  *padding-bottom: 1px;
+}
+.btn-link,
+.btn-link:active,
+.btn-link[disabled] {
+  background-color: transparent;
+  background-image: none;
+  -webkit-box-shadow: none;
+  -moz-box-shadow: none;
+  box-shadow: none;
+}
+.btn-link {
+  border-color: transparent;
+  cursor: pointer;
+  color: #0088cc;
+  -webkit-border-radius: 0;
+  -moz-border-radius: 0;
+  border-radius: 0;
+}
+.btn-link:hover,
+.btn-link:focus {
+  color: #005580;
+  text-decoration: underline;
+  background-color: transparent;
+}
+.btn-link[disabled]:hover,
+.btn-link[disabled]:focus {
+  color: #333333;
+  text-decoration: none;
+}
+[class^="icon-"],
+[class*=" icon-"] {
+  display: inline-block;
+  width: 14px;
+  height: 14px;
+  *margin-right: .3em;
+  line-height: 14px;
+  vertical-align: text-top;
+  background-image: url("../img/glyphicons-halflings.png");
+  background-position: 14px 14px;
+  background-repeat: no-repeat;
+  margin-top: 1px;
+}
+/* White icons with optional class, or on hover/focus/active states of certain elements */
+.icon-white,
+.nav-pills > .active > a > [class^="icon-"],
+.nav-pills > .active > a > [class*=" icon-"],
+.nav-list > .active > a > [class^="icon-"],
+.nav-list > .active > a > [class*=" icon-"],
+.navbar-inverse .nav > .active > a > [class^="icon-"],
+.navbar-inverse .nav > .active > a > [class*=" icon-"],
+.dropdown-menu > li > a:hover > [class^="icon-"],
+.dropdown-menu > li > a:focus > [class^="icon-"],
+.dropdown-menu > li > a:hover > [class*=" icon-"],
+.dropdown-menu > li > a:focus > [class*=" icon-"],
+.dropdown-menu > .active > a > [class^="icon-"],
+.dropdown-menu > .active > a > [class*=" icon-"],
+.dropdown-submenu:hover > a > [class^="icon-"],
+.dropdown-submenu:focus > a > [class^="icon-"],
+.dropdown-submenu:hover > a > [class*=" icon-"],
+.dropdown-submenu:focus > a > [class*=" icon-"] {
+  background-image: url("../img/glyphicons-halflings-white.png");
+}
+.icon-glass {
+  background-position: 0      0;
+}
+.icon-music {
+  background-position: -24px 0;
+}
+.icon-search {
+  background-position: -48px 0;
+}
+.icon-envelope {
+  background-position: -72px 0;
+}
+.icon-heart {
+  background-position: -96px 0;
+}
+.icon-star {
+  background-position: -120px 0;
+}
+.icon-star-empty {
+  background-position: -144px 0;
+}
+.icon-user {
+  background-position: -168px 0;
+}
+.icon-film {
+  background-position: -192px 0;
+}
+.icon-th-large {
+  background-position: -216px 0;
+}
+.icon-th {
+  background-position: -240px 0;
+}
+.icon-th-list {
+  background-position: -264px 0;
+}
+.icon-ok {
+  background-position: -288px 0;
+}
+.icon-remove {
+  background-position: -312px 0;
+}
+.icon-zoom-in {
+  background-position: -336px 0;
+}
+.icon-zoom-out {
+  background-position: -360px 0;
+}
+.icon-off {
+  background-position: -384px 0;
+}
+.icon-signal {
+  background-position: -408px 0;
+}
+.icon-cog {
+  background-position: -432px 0;
+}
+.icon-trash {
+  background-position: -456px 0;
+}
+.icon-home {
+  background-position: 0 -24px;
+}
+.icon-file {
+  background-position: -24px -24px;
+}
+.icon-time {
+  background-position: -48px -24px;
+}
+.icon-road {
+  background-position: -72px -24px;
+}
+.icon-download-alt {
+  background-position: -96px -24px;
+}
+.icon-download {
+  background-position: -120px -24px;
+}
+.icon-upload {
+  background-position: -144px -24px;
+}
+.icon-inbox {
+  background-position: -168px -24px;
+}
+.icon-play-circle {
+  background-position: -192px -24px;
+}
+.icon-repeat {
+  background-position: -216px -24px;
+}
+.icon-refresh {
+  background-position: -240px -24px;
+}
+.icon-list-alt {
+  background-position: -264px -24px;
+}
+.icon-lock {
+  background-position: -287px -24px;
+}
+.icon-flag {
+  background-position: -312px -24px;
+}
+.icon-headphones {
+  background-position: -336px -24px;
+}
+.icon-volume-off {
+  background-position: -360px -24px;
+}
+.icon-volume-down {
+  background-position: -384px -24px;
+}
+.icon-volume-up {
+  background-position: -408px -24px;
+}
+.icon-qrcode {
+  background-position: -432px -24px;
+}
+.icon-barcode {
+  background-position: -456px -24px;
+}
+.icon-tag {
+  background-position: 0 -48px;
+}
+.icon-tags {
+  background-position: -25px -48px;
+}
+.icon-book {
+  background-position: -48px -48px;
+}
+.icon-bookmark {
+  background-position: -72px -48px;
+}
+.icon-print {
+  background-position: -96px -48px;
+}
+.icon-camera {
+  background-position: -120px -48px;
+}
+.icon-font {
+  background-position: -144px -48px;
+}
+.icon-bold {
+  background-position: -167px -48px;
+}
+.icon-italic {
+  background-position: -192px -48px;
+}
+.icon-text-height {
+  background-position: -216px -48px;
+}
+.icon-text-width {
+  background-position: -240px -48px;
+}
+.icon-align-left {
+  background-position: -264px -48px;
+}
+.icon-align-center {
+  background-position: -288px -48px;
+}
+.icon-align-right {
+  background-position: -312px -48px;
+}
+.icon-align-justify {
+  background-position: -336px -48px;
+}
+.icon-list {
+  background-position: -360px -48px;
+}
+.icon-indent-left {
+  background-position: -384px -48px;
+}
+.icon-indent-right {
+  background-position: -408px -48px;
+}
+.icon-facetime-video {
+  background-position: -432px -48px;
+}
+.icon-picture {
+  background-position: -456px -48px;
+}
+.icon-pencil {
+  background-position: 0 -72px;
+}
+.icon-map-marker {
+  background-position: -24px -72px;
+}
+.icon-adjust {
+  background-position: -48px -72px;
+}
+.icon-tint {
+  background-position: -72px -72px;
+}
+.icon-edit {
+  background-position: -96px -72px;
+}
+.icon-share {
+  background-position: -120px -72px;
+}
+.icon-check {
+  background-position: -144px -72px;
+}
+.icon-move {
+  background-position: -168px -72px;
+}
+.icon-step-backward {
+  background-position: -192px -72px;
+}
+.icon-fast-backward {
+  background-position: -216px -72px;
+}
+.icon-backward {
+  background-position: -240px -72px;
+}
+.icon-play {
+  background-position: -264px -72px;
+}
+.icon-pause {
+  background-position: -288px -72px;
+}
+.icon-stop {
+  background-position: -312px -72px;
+}
+.icon-forward {
+  background-position: -336px -72px;
+}
+.icon-fast-forward {
+  background-position: -360px -72px;
+}
+.icon-step-forward {
+  background-position: -384px -72px;
+}
+.icon-eject {
+  background-position: -408px -72px;
+}
+.icon-chevron-left {
+  background-position: -432px -72px;
+}
+.icon-chevron-right {
+  background-position: -456px -72px;
+}
+.icon-plus-sign {
+  background-position: 0 -96px;
+}
+.icon-minus-sign {
+  background-position: -24px -96px;
+}
+.icon-remove-sign {
+  background-position: -48px -96px;
+}
+.icon-ok-sign {
+  background-position: -72px -96px;
+}
+.icon-question-sign {
+  background-position: -96px -96px;
+}
+.icon-info-sign {
+  background-position: -120px -96px;
+}
+.icon-screenshot {
+  background-position: -144px -96px;
+}
+.icon-remove-circle {
+  background-position: -168px -96px;
+}
+.icon-ok-circle {
+  background-position: -192px -96px;
+}
+.icon-ban-circle {
+  background-position: -216px -96px;
+}
+.icon-arrow-left {
+  background-position: -240px -96px;
+}
+.icon-arrow-right {
+  background-position: -264px -96px;
+}
+.icon-arrow-up {
+  background-position: -289px -96px;
+}
+.icon-arrow-down {
+  background-position: -312px -96px;
+}
+.icon-share-alt {
+  background-position: -336px -96px;
+}
+.icon-resize-full {
+  background-position: -360px -96px;
+}
+.icon-resize-small {
+  background-position: -384px -96px;
+}
+.icon-plus {
+  background-position: -408px -96px;
+}
+.icon-minus {
+  background-position: -433px -96px;
+}
+.icon-asterisk {
+  background-position: -456px -96px;
+}
+.icon-exclamation-sign {
+  background-position: 0 -120px;
+}
+.icon-gift {
+  background-position: -24px -120px;
+}
+.icon-leaf {
+  background-position: -48px -120px;
+}
+.icon-fire {
+  background-position: -72px -120px;
+}
+.icon-eye-open {
+  background-position: -96px -120px;
+}
+.icon-eye-close {
+  background-position: -120px -120px;
+}
+.icon-warning-sign {
+  background-position: -144px -120px;
+}
+.icon-plane {
+  background-position: -168px -120px;
+}
+.icon-calendar {
+  background-position: -192px -120px;
+}
+.icon-random {
+  background-position: -216px -120px;
+  width: 16px;
+}
+.icon-comment {
+  background-position: -240px -120px;
+}
+.icon-magnet {
+  background-position: -264px -120px;
+}
+.icon-chevron-up {
+  background-position: -288px -120px;
+}
+.icon-chevron-down {
+  background-position: -313px -119px;
+}
+.icon-retweet {
+  background-position: -336px -120px;
+}
+.icon-shopping-cart {
+  background-position: -360px -120px;
+}
+.icon-folder-close {
+  background-position: -384px -120px;
+  width: 16px;
+}
+.icon-folder-open {
+  background-position: -408px -120px;
+  width: 16px;
+}
+.icon-resize-vertical {
+  background-position: -432px -119px;
+}
+.icon-resize-horizontal {
+  background-position: -456px -118px;
+}
+.icon-hdd {
+  background-position: 0 -144px;
+}
+.icon-bullhorn {
+  background-position: -24px -144px;
+}
+.icon-bell {
+  background-position: -48px -144px;
+}
+.icon-certificate {
+  background-position: -72px -144px;
+}
+.icon-thumbs-up {
+  background-position: -96px -144px;
+}
+.icon-thumbs-down {
+  background-position: -120px -144px;
+}
+.icon-hand-right {
+  background-position: -144px -144px;
+}
+.icon-hand-left {
+  background-position: -168px -144px;
+}
+.icon-hand-up {
+  background-position: -192px -144px;
+}
+.icon-hand-down {
+  background-position: -216px -144px;
+}
+.icon-circle-arrow-right {
+  background-position: -240px -144px;
+}
+.icon-circle-arrow-left {
+  background-position: -264px -144px;
+}
+.icon-circle-arrow-up {
+  background-position: -288px -144px;
+}
+.icon-circle-arrow-down {
+  background-position: -312px -144px;
+}
+.icon-globe {
+  background-position: -336px -144px;
+}
+.icon-wrench {
+  background-position: -360px -144px;
+}
+.icon-tasks {
+  background-position: -384px -144px;
+}
+.icon-filter {
+  background-position: -408px -144px;
+}
+.icon-briefcase {
+  background-position: -432px -144px;
+}
+.icon-fullscreen {
+  background-position: -456px -144px;
+}
+.btn-group {
+  position: relative;
+  display: inline-block;
+  *display: inline;
+  /* IE7 inline-block hack */
+
+  *zoom: 1;
+  font-size: 0;
+  vertical-align: middle;
+  white-space: nowrap;
+  *margin-left: .3em;
+}
+.btn-group:first-child {
+  *margin-left: 0;
+}
+.btn-group + .btn-group {
+  margin-left: 5px;
+}
+.btn-toolbar {
+  font-size: 0;
+  margin-top: 10px;
+  margin-bottom: 10px;
+}
+.btn-toolbar > .btn + .btn,
+.btn-toolbar > .btn-group + .btn,
+.btn-toolbar > .btn + .btn-group {
+  margin-left: 5px;
+}
+.btn-group > .btn {
+  position: relative;
+  -webkit-border-radius: 0;
+  -moz-border-radius: 0;
+  border-radius: 0;
+}
+.btn-group > .btn + .btn {
+  margin-left: -1px;
+}
+.btn-group > .btn,
+.btn-group > .dropdown-menu,
+.btn-group > .popover {
+  font-size: 14px;
+}
+.btn-group > .btn-mini {
+  font-size: 10.5px;
+}
+.btn-group > .btn-small {
+  font-size: 11.9px;
+}
+.btn-group > .btn-large {
+  font-size: 17.5px;
+}
+.btn-group > .btn:first-child {
+  margin-left: 0;
+  -webkit-border-top-left-radius: 4px;
+  -moz-border-radius-topleft: 4px;
+  border-top-left-radius: 4px;
+  -webkit-border-bottom-left-radius: 4px;
+  -moz-border-radius-bottomleft: 4px;
+  border-bottom-left-radius: 4px;
+}
+.btn-group > .btn:last-child,
+.btn-group > .dropdown-toggle {
+  -webkit-border-top-right-radius: 4px;
+  -moz-border-radius-topright: 4px;
+  border-top-right-radius: 4px;
+  -webkit-border-bottom-right-radius: 4px;
+  -moz-border-radius-bottomright: 4px;
+  border-bottom-right-radius: 4px;
+}
+.btn-group > .btn.large:first-child {
+  margin-left: 0;
+  -webkit-border-top-left-radius: 6px;
+  -moz-border-radius-topleft: 6px;
+  border-top-left-radius: 6px;
+  -webkit-border-bottom-left-radius: 6px;
+  -moz-border-radius-bottomleft: 6px;
+  border-bottom-left-radius: 6px;
+}
+.btn-group > .btn.large:last-child,
+.btn-group > .large.dropdown-toggle {
+  -webkit-border-top-right-radius: 6px;
+  -moz-border-radius-topright: 6px;
+  border-top-right-radius: 6px;
+  -webkit-border-bottom-right-radius: 6px;
+  -moz-border-radius-bottomright: 6px;
+  border-bottom-right-radius: 6px;
+}
+.btn-group > .btn:hover,
+.btn-group > .btn:focus,
+.btn-group > .btn:active,
+.btn-group > .btn.active {
+  z-index: 2;
+}
+.btn-group .dropdown-toggle:active,
+.btn-group.open .dropdown-toggle {
+  outline: 0;
+}
+.btn-group > .btn + .dropdown-toggle {
+  padding-left: 8px;
+  padding-right: 8px;
+  -webkit-box-shadow: inset 1px 0 0 rgba(255,255,255,.125), inset 0 1px 0 rgba(255,255,255,.2), 0 1px 2px rgba(0,0,0,.05);
+  -moz-box-shadow: inset 1px 0 0 rgba(255,255,255,.125), inset 0 1px 0 rgba(255,255,255,.2), 0 1px 2px rgba(0,0,0,.05);
+  box-shadow: inset 1px 0 0 rgba(255,255,255,.125), inset 0 1px 0 rgba(255,255,255,.2), 0 1px 2px rgba(0,0,0,.05);
+  *padding-top: 5px;
+  *padding-bottom: 5px;
+}
+.btn-group > .btn-mini + .dropdown-toggle {
+  padding-left: 5px;
+  padding-right: 5px;
+  *padding-top: 2px;
+  *padding-bottom: 2px;
+}
+.btn-group > .btn-small + .dropdown-toggle {
+  *padding-top: 5px;
+  *padding-bottom: 4px;
+}
+.btn-group > .btn-large + .dropdown-toggle {
+  padding-left: 12px;
+  padding-right: 12px;
+  *padding-top: 7px;
+  *padding-bottom: 7px;
+}
+.btn-group.open .dropdown-toggle {
+  background-image: none;
+  -webkit-box-shadow: inset 0 2px 4px rgba(0,0,0,.15), 0 1px 2px rgba(0,0,0,.05);
+  -moz-box-shadow: inset 0 2px 4px rgba(0,0,0,.15), 0 1px 2px rgba(0,0,0,.05);
+  box-shadow: inset 0 2px 4px rgba(0,0,0,.15), 0 1px 2px rgba(0,0,0,.05);
+}
+.btn-group.open .btn.dropdown-toggle {
+  background-color: #e6e6e6;
+}
+.btn-group.open .btn-primary.dropdown-toggle {
+  background-color: #0044cc;
+}
+.btn-group.open .btn-warning.dropdown-toggle {
+  background-color: #f89406;
+}
+.btn-group.open .btn-danger.dropdown-toggle {
+  background-color: #bd362f;
+}
+.btn-group.open .btn-success.dropdown-toggle {
+  background-color: #51a351;
+}
+.btn-group.open .btn-info.dropdown-toggle {
+  background-color: #2f96b4;
+}
+.btn-group.open .btn-inverse.dropdown-toggle {
+  background-color: #222222;
+}
+.btn .caret {
+  margin-top: 8px;
+  margin-left: 0;
+}
+.btn-large .caret {
+  margin-top: 6px;
+}
+.btn-large .caret {
+  border-left-width: 5px;
+  border-right-width: 5px;
+  border-top-width: 5px;
+}
+.btn-mini .caret,
+.btn-small .caret {
+  margin-top: 8px;
+}
+.dropup .btn-large .caret {
+  border-bottom-width: 5px;
+}
+.btn-primary .caret,
+.btn-warning .caret,
+.btn-danger .caret,
+.btn-info .caret,
+.btn-success .caret,
+.btn-inverse .caret {
+  border-top-color: #ffffff;
+  border-bottom-color: #ffffff;
+}
+.btn-group-vertical {
+  display: inline-block;
+  *display: inline;
+  /* IE7 inline-block hack */
+
+  *zoom: 1;
+}
+.btn-group-vertical > .btn {
+  display: block;
+  float: none;
+  max-width: 100%;
+  -webkit-border-radius: 0;
+  -moz-border-radius: 0;
+  border-radius: 0;
+}
+.btn-group-vertical > .btn + .btn {
+  margin-left: 0;
+  margin-top: -1px;
+}
+.btn-group-vertical > .btn:first-child {
+  -webkit-border-radius: 4px 4px 0 0;
+  -moz-border-radius: 4px 4px 0 0;
+  border-radius: 4px 4px 0 0;
+}
+.btn-group-vertical > .btn:last-child {
+  -webkit-border-radius: 0 0 4px 4px;
+  -moz-border-radius: 0 0 4px 4px;
+  border-radius: 0 0 4px 4px;
+}
+.btn-group-vertical > .btn-large:first-child {
+  -webkit-border-radius: 6px 6px 0 0;
+  -moz-border-radius: 6px 6px 0 0;
+  border-radius: 6px 6px 0 0;
+}
+.btn-group-vertical > .btn-large:last-child {
+  -webkit-border-radius: 0 0 6px 6px;
+  -moz-border-radius: 0 0 6px 6px;
+  border-radius: 0 0 6px 6px;
+}
+.nav {
+  margin-left: 0;
+  margin-bottom: 20px;
+  list-style: none;
+}
+.nav > li > a {
+  display: block;
+}
+.nav > li > a:hover,
+.nav > li > a:focus {
+  text-decoration: none;
+  background-color: #eeeeee;
+}
+.nav > li > a > img {
+  max-width: none;
+}
+.nav > .pull-right {
+  float: right;
+}
+.nav-header {
+  display: block;
+  padding: 3px 15px;
+  font-size: 11px;
+  font-weight: bold;
+  line-height: 20px;
+  color: #999999;
+  text-shadow: 0 1px 0 rgba(255, 255, 255, 0.5);
+  text-transform: uppercase;
+}
+.nav li + .nav-header {
+  margin-top: 9px;
+}
+.nav-list {
+  padding-left: 15px;
+  padding-right: 15px;
+  margin-bottom: 0;
+}
+.nav-list > li > a,
+.nav-list .nav-header {
+  margin-left: -15px;
+  margin-right: -15px;
+  text-shadow: 0 1px 0 rgba(255, 255, 255, 0.5);
+}
+.nav-list > li > a {
+  padding: 3px 15px;
+}
+.nav-list > .active > a,
+.nav-list > .active > a:hover,
+.nav-list > .active > a:focus {
+  color: #ffffff;
+  text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.2);
+  background-color: #0088cc;
+}
+.nav-list [class^="icon-"],
+.nav-list [class*=" icon-"] {
+  margin-right: 2px;
+}
+.nav-list .divider {
+  *width: 100%;
+  height: 1px;
+  margin: 9px 1px;
+  *margin: -5px 0 5px;
+  overflow: hidden;
+  background-color: #e5e5e5;
+  border-bottom: 1px solid #ffffff;
+}
+.nav-tabs,
+.nav-pills {
+  *zoom: 1;
+}
+.nav-tabs:before,
+.nav-pills:before,
+.nav-tabs:after,
+.nav-pills:after {
+  display: table;
+  content: "";
+  line-height: 0;
+}
+.nav-tabs:after,
+.nav-pills:after {
+  clear: both;
+}
+.nav-tabs > li,
+.nav-pills > li {
+  float: left;
+}
+.nav-tabs > li > a,
+.nav-pills > li > a {
+  padding-right: 12px;
+  padding-left: 12px;
+  margin-right: 2px;
+  line-height: 14px;
+}
+.nav-tabs {
+  border-bottom: 1px solid #ddd;
+}
+.nav-tabs > li {
+  margin-bottom: -1px;
+}
+.nav-tabs > li > a {
+  padding-top: 8px;
+  padding-bottom: 8px;
+  line-height: 20px;
+  border: 1px solid transparent;
+  -webkit-border-radius: 4px 4px 0 0;
+  -moz-border-radius: 4px 4px 0 0;
+  border-radius: 4px 4px 0 0;
+}
+.nav-tabs > li > a:hover,
+.nav-tabs > li > a:focus {
+  border-color: #eeeeee #eeeeee #dddddd;
+}
+.nav-tabs > .active > a,
+.nav-tabs > .active > a:hover,
+.nav-tabs > .active > a:focus {
+  color: #555555;
+  background-color: #ffffff;
+  border: 1px solid #ddd;
+  border-bottom-color: transparent;
+  cursor: default;
+}
+.nav-pills > li > a {
+  padding-top: 8px;
+  padding-bottom: 8px;
+  margin-top: 2px;
+  margin-bottom: 2px;
+  -webkit-border-radius: 5px;
+  -moz-border-radius: 5px;
+  border-radius: 5px;
+}
+.nav-pills > .active > a,
+.nav-pills > .active > a:hover,
+.nav-pills > .active > a:focus {
+  color: #ffffff;
+  background-color: #0088cc;
+}
+.nav-stacked > li {
+  float: none;
+}
+.nav-stacked > li > a {
+  margin-right: 0;
+}
+.nav-tabs.nav-stacked {
+  border-bottom: 0;
+}
+.nav-tabs.nav-stacked > li > a {
+  border: 1px solid #ddd;
+  -webkit-border-radius: 0;
+  -moz-border-radius: 0;
+  border-radius: 0;
+}
+.nav-tabs.nav-stacked > li:first-child > a {
+  -webkit-border-top-right-radius: 4px;
+  -moz-border-radius-topright: 4px;
+  border-top-right-radius: 4px;
+  -webkit-border-top-left-radius: 4px;
+  -moz-border-radius-topleft: 4px;
+  border-top-left-radius: 4px;
+}
+.nav-tabs.nav-stacked > li:last-child > a {
+  -webkit-border-bottom-right-radius: 4px;
+  -moz-border-radius-bottomright: 4px;
+  border-bottom-right-radius: 4px;
+  -webkit-border-bottom-left-radius: 4px;
+  -moz-border-radius-bottomleft: 4px;
+  border-bottom-left-radius: 4px;
+}
+.nav-tabs.nav-stacked > li > a:hover,
+.nav-tabs.nav-stacked > li > a:focus {
+  border-color: #ddd;
+  z-index: 2;
+}
+.nav-pills.nav-stacked > li > a {
+  margin-bottom: 3px;
+}
+.nav-pills.nav-stacked > li:last-child > a {
+  margin-bottom: 1px;
+}
+.nav-tabs .dropdown-menu {
+  -webkit-border-radius: 0 0 6px 6px;
+  -moz-border-radius: 0 0 6px 6px;
+  border-radius: 0 0 6px 6px;
+}
+.nav-pills .dropdown-menu {
+  -webkit-border-radius: 6px;
+  -moz-border-radius: 6px;
+  border-radius: 6px;
+}
+.nav .dropdown-toggle .caret {
+  border-top-color: #0088cc;
+  border-bottom-color: #0088cc;
+  margin-top: 6px;
+}
+.nav .dropdown-toggle:hover .caret,
+.nav .dropdown-toggle:focus .caret {
+  border-top-color: #005580;
+  border-bottom-color: #005580;
+}
+/* move down carets for tabs */
+.nav-tabs .dropdown-toggle .caret {
+  margin-top: 8px;
+}
+.nav .active .dropdown-toggle .caret {
+  border-top-color: #fff;
+  border-bottom-color: #fff;
+}
+.nav-tabs .active .dropdown-toggle .caret {
+  border-top-color: #555555;
+  border-bottom-color: #555555;
+}
+.nav > .dropdown.active > a:hover,
+.nav > .dropdown.active > a:focus {
+  cursor: pointer;
+}
+.nav-tabs .open .dropdown-toggle,
+.nav-pills .open .dropdown-toggle,
+.nav > li.dropdown.open.active > a:hover,
+.nav > li.dropdown.open.active > a:focus {
+  color: #ffffff;
+  background-color: #999999;
+  border-color: #999999;
+}
+.nav li.dropdown.open .caret,
+.nav li.dropdown.open.active .caret,
+.nav li.dropdown.open a:hover .caret,
+.nav li.dropdown.open a:focus .caret {
+  border-top-color: #ffffff;
+  border-bottom-color: #ffffff;
+  opacity: 1;
+  filter: alpha(opacity=100);
+}
+.tabs-stacked .open > a:hover,
+.tabs-stacked .open > a:focus {
+  border-color: #999999;
+}
+.tabbable {
+  *zoom: 1;
+}
+.tabbable:before,
+.tabbable:after {
+  display: table;
+  content: "";
+  line-height: 0;
+}
+.tabbable:after {
+  clear: both;
+}
+.tab-content {
+  overflow: auto;
+}
+.tabs-below > .nav-tabs,
+.tabs-right > .nav-tabs,
+.tabs-left > .nav-tabs {
+  border-bottom: 0;
+}
+.tab-content > .tab-pane,
+.pill-content > .pill-pane {
+  display: none;
+}
+.tab-content > .active,
+.pill-content > .active {
+  display: block;
+}
+.tabs-below > .nav-tabs {
+  border-top: 1px solid #ddd;
+}
+.tabs-below > .nav-tabs > li {
+  margin-top: -1px;
+  margin-bottom: 0;
+}
+.tabs-below > .nav-tabs > li > a {
+  -webkit-border-radius: 0 0 4px 4px;
+  -moz-border-radius: 0 0 4px 4px;
+  border-radius: 0 0 4px 4px;
+}
+.tabs-below > .nav-tabs > li > a:hover,
+.tabs-below > .nav-tabs > li > a:focus {
+  border-bottom-color: transparent;
+  border-top-color: #ddd;
+}
+.tabs-below > .nav-tabs > .active > a,
+.tabs-below > .nav-tabs > .active > a:hover,
+.tabs-below > .nav-tabs > .active > a:focus {
+  border-color: transparent #ddd #ddd #ddd;
+}
+.tabs-left > .nav-tabs > li,
+.tabs-right > .nav-tabs > li {
+  float: none;
+}
+.tabs-left > .nav-tabs > li > a,
+.tabs-right > .nav-tabs > li > a {
+  min-width: 74px;
+  margin-right: 0;
+  margin-bottom: 3px;
+}
+.tabs-left > .nav-tabs {
+  float: left;
+  margin-right: 19px;
+  border-right: 1px solid #ddd;
+}
+.tabs-left > .nav-tabs > li > a {
+  margin-right: -1px;
+  -webkit-border-radius: 4px 0 0 4px;
+  -moz-border-radius: 4px 0 0 4px;
+  border-radius: 4px 0 0 4px;
+}
+.tabs-left > .nav-tabs > li > a:hover,
+.tabs-left > .nav-tabs > li > a:focus {
+  border-color: #eeeeee #dddddd #eeeeee #eeeeee;
+}
+.tabs-left > .nav-tabs .active > a,
+.tabs-left > .nav-tabs .active > a:hover,
+.tabs-left > .nav-tabs .active > a:focus {
+  border-color: #ddd transparent #ddd #ddd;
+  *border-right-color: #ffffff;
+}
+.tabs-right > .nav-tabs {
+  float: right;
+  margin-left: 19px;
+  border-left: 1px solid #ddd;
+}
+.tabs-right > .nav-tabs > li > a {
+  margin-left: -1px;
+  -webkit-border-radius: 0 4px 4px 0;
+  -moz-border-radius: 0 4px 4px 0;
+  border-radius: 0 4px 4px 0;
+}
+.tabs-right > .nav-tabs > li > a:hover,
+.tabs-right > .nav-tabs > li > a:focus {
+  border-color: #eeeeee #eeeeee #eeeeee #dddddd;
+}
+.tabs-right > .nav-tabs .active > a,
+.tabs-right > .nav-tabs .active > a:hover,
+.tabs-right > .nav-tabs .active > a:focus {
+  border-color: #ddd #ddd #ddd transparent;
+  *border-left-color: #ffffff;
+}
+.nav > .disabled > a {
+  color: #999999;
+}
+.nav > .disabled > a:hover,
+.nav > .disabled > a:focus {
+  text-decoration: none;
+  background-color: transparent;
+  cursor: default;
+}
+.navbar {
+  overflow: visible;
+  margin-bottom: 20px;
+  *position: relative;
+  *z-index: 2;
+}
+.navbar-inner {
+  min-height: 40px;
+  padding-left: 20px;
+  padding-right: 20px;
+  background-color: #fafafa;
+  background-image: -moz-linear-gradient(top, #ffffff, #f2f2f2);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#ffffff), to(#f2f2f2));
+  background-image: -webkit-linear-gradient(top, #ffffff, #f2f2f2);
+  background-image: -o-linear-gradient(top, #ffffff, #f2f2f2);
+  background-image: linear-gradient(to bottom, #ffffff, #f2f2f2);
+  background-repeat: repeat-x;
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffffffff', endColorstr='#fff2f2f2', GradientType=0);
+  border: 1px solid #d4d4d4;
+  -webkit-border-radius: 4px;
+  -moz-border-radius: 4px;
+  border-radius: 4px;
+  -webkit-box-shadow: 0 1px 4px rgba(0, 0, 0, 0.065);
+  -moz-box-shadow: 0 1px 4px rgba(0, 0, 0, 0.065);
+  box-shadow: 0 1px 4px rgba(0, 0, 0, 0.065);
+  *zoom: 1;
+}
+.navbar-inner:before,
+.navbar-inner:after {
+  display: table;
+  content: "";
+  line-height: 0;
+}
+.navbar-inner:after {
+  clear: both;
+}
+.navbar .container {
+  width: auto;
+}
+.nav-collapse.collapse {
+  height: auto;
+  overflow: visible;
+}
+.navbar .brand {
+  float: left;
+  display: block;
+  padding: 10px 20px 10px;
+  margin-left: -20px;
+  font-size: 20px;
+  font-weight: 200;
+  color: #777777;
+  text-shadow: 0 1px 0 #ffffff;
+}
+.navbar .brand:hover,
+.navbar .brand:focus {
+  text-decoration: none;
+}
+.navbar-text {
+  margin-bottom: 0;
+  line-height: 40px;
+  color: #777777;
+}
+.navbar-link {
+  color: #777777;
+}
+.navbar-link:hover,
+.navbar-link:focus {
+  color: #333333;
+}
+.navbar .divider-vertical {
+  height: 40px;
+  margin: 0 9px;
+  border-left: 1px solid #f2f2f2;
+  border-right: 1px solid #ffffff;
+}
+.navbar .btn,
+.navbar .btn-group {
+  margin-top: 5px;
+}
+.navbar .btn-group .btn,
+.navbar .input-prepend .btn,
+.navbar .input-append .btn,
+.navbar .input-prepend .btn-group,
+.navbar .input-append .btn-group {
+  margin-top: 0;
+}
+.navbar-form {
+  margin-bottom: 0;
+  *zoom: 1;
+}
+.navbar-form:before,
+.navbar-form:after {
+  display: table;
+  content: "";
+  line-height: 0;
+}
+.navbar-form:after {
+  clear: both;
+}
+.navbar-form input,
+.navbar-form select,
+.navbar-form .radio,
+.navbar-form .checkbox {
+  margin-top: 5px;
+}
+.navbar-form input,
+.navbar-form select,
+.navbar-form .btn {
+  display: inline-block;
+  margin-bottom: 0;
+}
+.navbar-form input[type="image"],
+.navbar-form input[type="checkbox"],
+.navbar-form input[type="radio"] {
+  margin-top: 3px;
+}
+.navbar-form .input-append,
+.navbar-form .input-prepend {
+  margin-top: 5px;
+  white-space: nowrap;
+}
+.navbar-form .input-append input,
+.navbar-form .input-prepend input {
+  margin-top: 0;
+}
+.navbar-search {
+  position: relative;
+  float: left;
+  margin-top: 5px;
+  margin-bottom: 0;
+}
+.navbar-search .search-query {
+  margin-bottom: 0;
+  padding: 4px 14px;
+  font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+  font-size: 13px;
+  font-weight: normal;
+  line-height: 1;
+  -webkit-border-radius: 15px;
+  -moz-border-radius: 15px;
+  border-radius: 15px;
+}
+.navbar-static-top {
+  position: static;
+  margin-bottom: 0;
+}
+.navbar-static-top .navbar-inner {
+  -webkit-border-radius: 0;
+  -moz-border-radius: 0;
+  border-radius: 0;
+}
+.navbar-fixed-top,
+.navbar-fixed-bottom {
+  position: fixed;
+  right: 0;
+  left: 0;
+  z-index: 1030;
+  margin-bottom: 0;
+}
+.navbar-fixed-top .navbar-inner,
+.navbar-static-top .navbar-inner {
+  border-width: 0 0 1px;
+}
+.navbar-fixed-bottom .navbar-inner {
+  border-width: 1px 0 0;
+}
+.navbar-fixed-top .navbar-inner,
+.navbar-fixed-bottom .navbar-inner {
+  padding-left: 0;
+  padding-right: 0;
+  -webkit-border-radius: 0;
+  -moz-border-radius: 0;
+  border-radius: 0;
+}
+.navbar-static-top .container,
+.navbar-fixed-top .container,
+.navbar-fixed-bottom .container {
+  width: 940px;
+}
+.navbar-fixed-top {
+  top: 0;
+}
+.navbar-fixed-top .navbar-inner,
+.navbar-static-top .navbar-inner {
+  -webkit-box-shadow: 0 1px 10px rgba(0,0,0,.1);
+  -moz-box-shadow: 0 1px 10px rgba(0,0,0,.1);
+  box-shadow: 0 1px 10px rgba(0,0,0,.1);
+}
+.navbar-fixed-bottom {
+  bottom: 0;
+}
+.navbar-fixed-bottom .navbar-inner {
+  -webkit-box-shadow: 0 -1px 10px rgba(0,0,0,.1);
+  -moz-box-shadow: 0 -1px 10px rgba(0,0,0,.1);
+  box-shadow: 0 -1px 10px rgba(0,0,0,.1);
+}
+.navbar .nav {
+  position: relative;
+  left: 0;
+  display: block;
+  float: left;
+  margin: 0 10px 0 0;
+}
+.navbar .nav.pull-right {
+  float: right;
+  margin-right: 0;
+}
+.navbar .nav > li {
+  float: left;
+}
+.navbar .nav > li > a {
+  float: none;
+  padding: 10px 15px 10px;
+  color: #777777;
+  text-decoration: none;
+  text-shadow: 0 1px 0 #ffffff;
+}
+.navbar .nav .dropdown-toggle .caret {
+  margin-top: 8px;
+}
+.navbar .nav > li > a:focus,
+.navbar .nav > li > a:hover {
+  background-color: transparent;
+  color: #333333;
+  text-decoration: none;
+}
+.navbar .nav > .active > a,
+.navbar .nav > .active > a:hover,
+.navbar .nav > .active > a:focus {
+  color: #555555;
+  text-decoration: none;
+  background-color: #e5e5e5;
+  -webkit-box-shadow: inset 0 3px 8px rgba(0, 0, 0, 0.125);
+  -moz-box-shadow: inset 0 3px 8px rgba(0, 0, 0, 0.125);
+  box-shadow: inset 0 3px 8px rgba(0, 0, 0, 0.125);
+}
+.navbar .btn-navbar {
+  display: none;
+  float: right;
+  padding: 7px 10px;
+  margin-left: 5px;
+  margin-right: 5px;
+  color: #ffffff;
+  text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
+  background-color: #ededed;
+  background-image: -moz-linear-gradient(top, #f2f2f2, #e5e5e5);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#f2f2f2), to(#e5e5e5));
+  background-image: -webkit-linear-gradient(top, #f2f2f2, #e5e5e5);
+  background-image: -o-linear-gradient(top, #f2f2f2, #e5e5e5);
+  background-image: linear-gradient(to bottom, #f2f2f2, #e5e5e5);
+  background-repeat: repeat-x;
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff2f2f2', endColorstr='#ffe5e5e5', GradientType=0);
+  border-color: #e5e5e5 #e5e5e5 #bfbfbf;
+  border-color: rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);
+  *background-color: #e5e5e5;
+  /* Darken IE7 buttons by default so they stand out more given they won't have borders */
+
+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
+  -webkit-box-shadow: inset 0 1px 0 rgba(255,255,255,.1), 0 1px 0 rgba(255,255,255,.075);
+  -moz-box-shadow: inset 0 1px 0 rgba(255,255,255,.1), 0 1px 0 rgba(255,255,255,.075);
+  box-shadow: inset 0 1px 0 rgba(255,255,255,.1), 0 1px 0 rgba(255,255,255,.075);
+}
+.navbar .btn-navbar:hover,
+.navbar .btn-navbar:focus,
+.navbar .btn-navbar:active,
+.navbar .btn-navbar.active,
+.navbar .btn-navbar.disabled,
+.navbar .btn-navbar[disabled] {
+  color: #ffffff;
+  background-color: #e5e5e5;
+  *background-color: #d9d9d9;
+}
+.navbar .btn-navbar:active,
+.navbar .btn-navbar.active {
+  background-color: #cccccc \9;
+}
+.navbar .btn-navbar .icon-bar {
+  display: block;
+  width: 18px;
+  height: 2px;
+  background-color: #f5f5f5;
+  -webkit-border-radius: 1px;
+  -moz-border-radius: 1px;
+  border-radius: 1px;
+  -webkit-box-shadow: 0 1px 0 rgba(0, 0, 0, 0.25);
+  -moz-box-shadow: 0 1px 0 rgba(0, 0, 0, 0.25);
+  box-shadow: 0 1px 0 rgba(0, 0, 0, 0.25);
+}
+.btn-navbar .icon-bar + .icon-bar {
+  margin-top: 3px;
+}
+.navbar .nav > li > .dropdown-menu:before {
+  content: '';
+  display: inline-block;
+  border-left: 7px solid transparent;
+  border-right: 7px solid transparent;
+  border-bottom: 7px solid #ccc;
+  border-bottom-color: rgba(0, 0, 0, 0.2);
+  position: absolute;
+  top: -7px;
+  left: 9px;
+}
+.navbar .nav > li > .dropdown-menu:after {
+  content: '';
+  display: inline-block;
+  border-left: 6px solid transparent;
+  border-right: 6px solid transparent;
+  border-bottom: 6px solid #ffffff;
+  position: absolute;
+  top: -6px;
+  left: 10px;
+}
+.navbar-fixed-bottom .nav > li > .dropdown-menu:before {
+  border-top: 7px solid #ccc;
+  border-top-color: rgba(0, 0, 0, 0.2);
+  border-bottom: 0;
+  bottom: -7px;
+  top: auto;
+}
+.navbar-fixed-bottom .nav > li > .dropdown-menu:after {
+  border-top: 6px solid #ffffff;
+  border-bottom: 0;
+  bottom: -6px;
+  top: auto;
+}
+.navbar .nav li.dropdown > a:hover .caret,
+.navbar .nav li.dropdown > a:focus .caret {
+  border-top-color: #333333;
+  border-bottom-color: #333333;
+}
+.navbar .nav li.dropdown.open > .dropdown-toggle,
+.navbar .nav li.dropdown.active > .dropdown-toggle,
+.navbar .nav li.dropdown.open.active > .dropdown-toggle {
+  background-color: #e5e5e5;
+  color: #555555;
+}
+.navbar .nav li.dropdown > .dropdown-toggle .caret {
+  border-top-color: #777777;
+  border-bottom-color: #777777;
+}
+.navbar .nav li.dropdown.open > .dropdown-toggle .caret,
+.navbar .nav li.dropdown.active > .dropdown-toggle .caret,
+.navbar .nav li.dropdown.open.active > .dropdown-toggle .caret {
+  border-top-color: #555555;
+  border-bottom-color: #555555;
+}
+.navbar .pull-right > li > .dropdown-menu,
+.navbar .nav > li > .dropdown-menu.pull-right {
+  left: auto;
+  right: 0;
+}
+.navbar .pull-right > li > .dropdown-menu:before,
+.navbar .nav > li > .dropdown-menu.pull-right:before {
+  left: auto;
+  right: 12px;
+}
+.navbar .pull-right > li > .dropdown-menu:after,
+.navbar .nav > li > .dropdown-menu.pull-right:after {
+  left: auto;
+  right: 13px;
+}
+.navbar .pull-right > li > .dropdown-menu .dropdown-menu,
+.navbar .nav > li > .dropdown-menu.pull-right .dropdown-menu {
+  left: auto;
+  right: 100%;
+  margin-left: 0;
+  margin-right: -1px;
+  -webkit-border-radius: 6px 0 6px 6px;
+  -moz-border-radius: 6px 0 6px 6px;
+  border-radius: 6px 0 6px 6px;
+}
+.navbar-inverse .navbar-inner {
+  background-color: #1b1b1b;
+  background-image: -moz-linear-gradient(top, #222222, #111111);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#222222), to(#111111));
+  background-image: -webkit-linear-gradient(top, #222222, #111111);
+  background-image: -o-linear-gradient(top, #222222, #111111);
+  background-image: linear-gradient(to bottom, #222222, #111111);
+  background-repeat: repeat-x;
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff222222', endColorstr='#ff111111', GradientType=0);
+  border-color: #252525;
+}
+.navbar-inverse .brand,
+.navbar-inverse .nav > li > a {
+  color: #999999;
+  text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
+}
+.navbar-inverse .brand:hover,
+.navbar-inverse .nav > li > a:hover,
+.navbar-inverse .brand:focus,
+.navbar-inverse .nav > li > a:focus {
+  color: #ffffff;
+}
+.navbar-inverse .brand {
+  color: #999999;
+}
+.navbar-inverse .navbar-text {
+  color: #999999;
+}
+.navbar-inverse .nav > li > a:focus,
+.navbar-inverse .nav > li > a:hover {
+  background-color: transparent;
+  color: #ffffff;
+}
+.navbar-inverse .nav .active > a,
+.navbar-inverse .nav .active > a:hover,
+.navbar-inverse .nav .active > a:focus {
+  color: #ffffff;
+  background-color: #111111;
+}
+.navbar-inverse .navbar-link {
+  color: #999999;
+}
+.navbar-inverse .navbar-link:hover,
+.navbar-inverse .navbar-link:focus {
+  color: #ffffff;
+}
+.navbar-inverse .divider-vertical {
+  border-left-color: #111111;
+  border-right-color: #222222;
+}
+.navbar-inverse .nav li.dropdown.open > .dropdown-toggle,
+.navbar-inverse .nav li.dropdown.active > .dropdown-toggle,
+.navbar-inverse .nav li.dropdown.open.active > .dropdown-toggle {
+  background-color: #111111;
+  color: #ffffff;
+}
+.navbar-inverse .nav li.dropdown > a:hover .caret,
+.navbar-inverse .nav li.dropdown > a:focus .caret {
+  border-top-color: #ffffff;
+  border-bottom-color: #ffffff;
+}
+.navbar-inverse .nav li.dropdown > .dropdown-toggle .caret {
+  border-top-color: #999999;
+  border-bottom-color: #999999;
+}
+.navbar-inverse .nav li.dropdown.open > .dropdown-toggle .caret,
+.navbar-inverse .nav li.dropdown.active > .dropdown-toggle .caret,
+.navbar-inverse .nav li.dropdown.open.active > .dropdown-toggle .caret {
+  border-top-color: #ffffff;
+  border-bottom-color: #ffffff;
+}
+.navbar-inverse .navbar-search .search-query {
+  color: #ffffff;
+  background-color: #515151;
+  border-color: #111111;
+  -webkit-box-shadow: inset 0 1px 2px rgba(0,0,0,.1), 0 1px 0 rgba(255,255,255,.15);
+  -moz-box-shadow: inset 0 1px 2px rgba(0,0,0,.1), 0 1px 0 rgba(255,255,255,.15);
+  box-shadow: inset 0 1px 2px rgba(0,0,0,.1), 0 1px 0 rgba(255,255,255,.15);
+  -webkit-transition: none;
+  -moz-transition: none;
+  -o-transition: none;
+  transition: none;
+}
+.navbar-inverse .navbar-search .search-query:-moz-placeholder {
+  color: #cccccc;
+}
+.navbar-inverse .navbar-search .search-query:-ms-input-placeholder {
+  color: #cccccc;
+}
+.navbar-inverse .navbar-search .search-query::-webkit-input-placeholder {
+  color: #cccccc;
+}
+.navbar-inverse .navbar-search .search-query:focus,
+.navbar-inverse .navbar-search .search-query.focused {
+  padding: 5px 15px;
+  color: #333333;
+  text-shadow: 0 1px 0 #ffffff;
+  background-color: #ffffff;
+  border: 0;
+  -webkit-box-shadow: 0 0 3px rgba(0, 0, 0, 0.15);
+  -moz-box-shadow: 0 0 3px rgba(0, 0, 0, 0.15);
+  box-shadow: 0 0 3px rgba(0, 0, 0, 0.15);
+  outline: 0;
+}
+.navbar-inverse .btn-navbar {
+  color: #ffffff;
+  text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
+  background-color: #0e0e0e;
+  background-image: -moz-linear-gradient(top, #151515, #040404);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#151515), to(#040404));
+  background-image: -webkit-linear-gradient(top, #151515, #040404);
+  background-image: -o-linear-gradient(top, #151515, #040404);
+  background-image: linear-gradient(to bottom, #151515, #040404);
+  background-repeat: repeat-x;
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff151515', endColorstr='#ff040404', GradientType=0);
+  border-color: #040404 #040404 #000000;
+  border-color: rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);
+  *background-color: #040404;
+  /* Darken IE7 buttons by default so they stand out more given they won't have borders */
+
+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
+}
+.navbar-inverse .btn-navbar:hover,
+.navbar-inverse .btn-navbar:focus,
+.navbar-inverse .btn-navbar:active,
+.navbar-inverse .btn-navbar.active,
+.navbar-inverse .btn-navbar.disabled,
+.navbar-inverse .btn-navbar[disabled] {
+  color: #ffffff;
+  background-color: #040404;
+  *background-color: #000000;
+}
+.navbar-inverse .btn-navbar:active,
+.navbar-inverse .btn-navbar.active {
+  background-color: #000000 \9;
+}
+.breadcrumb {
+  padding: 8px 15px;
+  margin: 0 0 20px;
+  list-style: none;
+  background-color: #f5f5f5;
+  -webkit-border-radius: 4px;
+  -moz-border-radius: 4px;
+  border-radius: 4px;
+}
+.breadcrumb > li {
+  display: inline-block;
+  *display: inline;
+  /* IE7 inline-block hack */
+
+  *zoom: 1;
+  text-shadow: 0 1px 0 #ffffff;
+}
+.breadcrumb > li > .divider {
+  padding: 0 5px;
+  color: #ccc;
+}
+.breadcrumb > .active {
+  color: #999999;
+}
+.pagination {
+  margin: 20px 0;
+}
+.pagination ul {
+  display: inline-block;
+  *display: inline;
+  /* IE7 inline-block hack */
+
+  *zoom: 1;
+  margin-left: 0;
+  margin-bottom: 0;
+  -webkit-border-radius: 4px;
+  -moz-border-radius: 4px;
+  border-radius: 4px;
+  -webkit-box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);
+  -moz-box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);
+  box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);
+}
+.pagination ul > li {
+  display: inline;
+}
+.pagination ul > li > a,
+.pagination ul > li > span {
+  float: left;
+  padding: 4px 12px;
+  line-height: 20px;
+  text-decoration: none;
+  background-color: #ffffff;
+  border: 1px solid #dddddd;
+  border-left-width: 0;
+}
+.pagination ul > li > a:hover,
+.pagination ul > li > a:focus,
+.pagination ul > .active > a,
+.pagination ul > .active > span {
+  background-color: #f5f5f5;
+}
+.pagination ul > .active > a,
+.pagination ul > .active > span {
+  color: #999999;
+  cursor: default;
+}
+.pagination ul > .disabled > span,
+.pagination ul > .disabled > a,
+.pagination ul > .disabled > a:hover,
+.pagination ul > .disabled > a:focus {
+  color: #999999;
+  background-color: transparent;
+  cursor: default;
+}
+.pagination ul > li:first-child > a,
+.pagination ul > li:first-child > span {
+  border-left-width: 1px;
+  -webkit-border-top-left-radius: 4px;
+  -moz-border-radius-topleft: 4px;
+  border-top-left-radius: 4px;
+  -webkit-border-bottom-left-radius: 4px;
+  -moz-border-radius-bottomleft: 4px;
+  border-bottom-left-radius: 4px;
+}
+.pagination ul > li:last-child > a,
+.pagination ul > li:last-child > span {
+  -webkit-border-top-right-radius: 4px;
+  -moz-border-radius-topright: 4px;
+  border-top-right-radius: 4px;
+  -webkit-border-bottom-right-radius: 4px;
+  -moz-border-radius-bottomright: 4px;
+  border-bottom-right-radius: 4px;
+}
+.pagination-centered {
+  text-align: center;
+}
+.pagination-right {
+  text-align: right;
+}
+.pagination-large ul > li > a,
+.pagination-large ul > li > span {
+  padding: 11px 19px;
+  font-size: 17.5px;
+}
+.pagination-large ul > li:first-child > a,
+.pagination-large ul > li:first-child > span {
+  -webkit-border-top-left-radius: 6px;
+  -moz-border-radius-topleft: 6px;
+  border-top-left-radius: 6px;
+  -webkit-border-bottom-left-radius: 6px;
+  -moz-border-radius-bottomleft: 6px;
+  border-bottom-left-radius: 6px;
+}
+.pagination-large ul > li:last-child > a,
+.pagination-large ul > li:last-child > span {
+  -webkit-border-top-right-radius: 6px;
+  -moz-border-radius-topright: 6px;
+  border-top-right-radius: 6px;
+  -webkit-border-bottom-right-radius: 6px;
+  -moz-border-radius-bottomright: 6px;
+  border-bottom-right-radius: 6px;
+}
+.pagination-mini ul > li:first-child > a,
+.pagination-small ul > li:first-child > a,
+.pagination-mini ul > li:first-child > span,
+.pagination-small ul > li:first-child > span {
+  -webkit-border-top-left-radius: 3px;
+  -moz-border-radius-topleft: 3px;
+  border-top-left-radius: 3px;
+  -webkit-border-bottom-left-radius: 3px;
+  -moz-border-radius-bottomleft: 3px;
+  border-bottom-left-radius: 3px;
+}
+.pagination-mini ul > li:last-child > a,
+.pagination-small ul > li:last-child > a,
+.pagination-mini ul > li:last-child > span,
+.pagination-small ul > li:last-child > span {
+  -webkit-border-top-right-radius: 3px;
+  -moz-border-radius-topright: 3px;
+  border-top-right-radius: 3px;
+  -webkit-border-bottom-right-radius: 3px;
+  -moz-border-radius-bottomright: 3px;
+  border-bottom-right-radius: 3px;
+}
+.pagination-small ul > li > a,
+.pagination-small ul > li > span {
+  padding: 2px 10px;
+  font-size: 11.9px;
+}
+.pagination-mini ul > li > a,
+.pagination-mini ul > li > span {
+  padding: 0 6px;
+  font-size: 10.5px;
+}
+.pager {
+  margin: 20px 0;
+  list-style: none;
+  text-align: center;
+  *zoom: 1;
+}
+.pager:before,
+.pager:after {
+  display: table;
+  content: "";
+  line-height: 0;
+}
+.pager:after {
+  clear: both;
+}
+.pager li {
+  display: inline;
+}
+.pager li > a,
+.pager li > span {
+  display: inline-block;
+  padding: 5px 14px;
+  background-color: #fff;
+  border: 1px solid #ddd;
+  -webkit-border-radius: 15px;
+  -moz-border-radius: 15px;
+  border-radius: 15px;
+}
+.pager li > a:hover,
+.pager li > a:focus {
+  text-decoration: none;
+  background-color: #f5f5f5;
+}
+.pager .next > a,
+.pager .next > span {
+  float: right;
+}
+.pager .previous > a,
+.pager .previous > span {
+  float: left;
+}
+.pager .disabled > a,
+.pager .disabled > a:hover,
+.pager .disabled > a:focus,
+.pager .disabled > span {
+  color: #999999;
+  background-color: #fff;
+  cursor: default;
+}
+.thumbnails {
+  margin-left: -20px;
+  list-style: none;
+  *zoom: 1;
+}
+.thumbnails:before,
+.thumbnails:after {
+  display: table;
+  content: "";
+  line-height: 0;
+}
+.thumbnails:after {
+  clear: both;
+}
+.row-fluid .thumbnails {
+  margin-left: 0;
+}
+.thumbnails > li {
+  float: left;
+  margin-bottom: 20px;
+  margin-left: 20px;
+}
+.thumbnail {
+  display: block;
+  padding: 4px;
+  line-height: 20px;
+  border: 1px solid #ddd;
+  -webkit-border-radius: 4px;
+  -moz-border-radius: 4px;
+  border-radius: 4px;
+  -webkit-box-shadow: 0 1px 3px rgba(0, 0, 0, 0.055);
+  -moz-box-shadow: 0 1px 3px rgba(0, 0, 0, 0.055);
+  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.055);
+  -webkit-transition: all 0.2s ease-in-out;
+  -moz-transition: all 0.2s ease-in-out;
+  -o-transition: all 0.2s ease-in-out;
+  transition: all 0.2s ease-in-out;
+}
+a.thumbnail:hover,
+a.thumbnail:focus {
+  border-color: #0088cc;
+  -webkit-box-shadow: 0 1px 4px rgba(0, 105, 214, 0.25);
+  -moz-box-shadow: 0 1px 4px rgba(0, 105, 214, 0.25);
+  box-shadow: 0 1px 4px rgba(0, 105, 214, 0.25);
+}
+.thumbnail > img {
+  display: block;
+  max-width: 100%;
+  margin-left: auto;
+  margin-right: auto;
+}
+.thumbnail .caption {
+  padding: 9px;
+  color: #555555;
+}
+.alert {
+  padding: 8px 35px 8px 14px;
+  margin-bottom: 20px;
+  text-shadow: 0 1px 0 rgba(255, 255, 255, 0.5);
+  background-color: #fcf8e3;
+  border: 1px solid #fbeed5;
+  -webkit-border-radius: 4px;
+  -moz-border-radius: 4px;
+  border-radius: 4px;
+}
+.alert,
+.alert h4 {
+  color: #c09853;
+}
+.alert h4 {
+  margin: 0;
+}
+.alert .close {
+  position: relative;
+  top: -2px;
+  right: -21px;
+  line-height: 20px;
+}
+.alert-success {
+  background-color: #dff0d8;
+  border-color: #d6e9c6;
+  color: #468847;
+}
+.alert-success h4 {
+  color: #468847;
+}
+.alert-danger,
+.alert-error {
+  background-color: #f2dede;
+  border-color: #eed3d7;
+  color: #b94a48;
+}
+.alert-danger h4,
+.alert-error h4 {
+  color: #b94a48;
+}
+.alert-info {
+  background-color: #d9edf7;
+  border-color: #bce8f1;
+  color: #3a87ad;
+}
+.alert-info h4 {
+  color: #3a87ad;
+}
+.alert-block {
+  padding-top: 14px;
+  padding-bottom: 14px;
+}
+.alert-block > p,
+.alert-block > ul {
+  margin-bottom: 0;
+}
+.alert-block p + p {
+  margin-top: 5px;
+}
+@-webkit-keyframes progress-bar-stripes {
+  from {
+    background-position: 40px 0;
+  }
+  to {
+    background-position: 0 0;
+  }
+}
+@-moz-keyframes progress-bar-stripes {
+  from {
+    background-position: 40px 0;
+  }
+  to {
+    background-position: 0 0;
+  }
+}
+@-ms-keyframes progress-bar-stripes {
+  from {
+    background-position: 40px 0;
+  }
+  to {
+    background-position: 0 0;
+  }
+}
+@-o-keyframes progress-bar-stripes {
+  from {
+    background-position: 0 0;
+  }
+  to {
+    background-position: 40px 0;
+  }
+}
+@keyframes progress-bar-stripes {
+  from {
+    background-position: 40px 0;
+  }
+  to {
+    background-position: 0 0;
+  }
+}
+.progress {
+  overflow: hidden;
+  height: 20px;
+  margin-bottom: 20px;
+  background-color: #f7f7f7;
+  background-image: -moz-linear-gradient(top, #f5f5f5, #f9f9f9);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#f5f5f5), to(#f9f9f9));
+  background-image: -webkit-linear-gradient(top, #f5f5f5, #f9f9f9);
+  background-image: -o-linear-gradient(top, #f5f5f5, #f9f9f9);
+  background-image: linear-gradient(to bottom, #f5f5f5, #f9f9f9);
+  background-repeat: repeat-x;
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff5f5f5', endColorstr='#fff9f9f9', GradientType=0);
+  -webkit-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1);
+  -moz-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1);
+  box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1);
+  -webkit-border-radius: 4px;
+  -moz-border-radius: 4px;
+  border-radius: 4px;
+}
+.progress .bar {
+  width: 0%;
+  height: 100%;
+  color: #ffffff;
+  float: left;
+  font-size: 12px;
+  text-align: center;
+  text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
+  background-color: #0e90d2;
+  background-image: -moz-linear-gradient(top, #149bdf, #0480be);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#149bdf), to(#0480be));
+  background-image: -webkit-linear-gradient(top, #149bdf, #0480be);
+  background-image: -o-linear-gradient(top, #149bdf, #0480be);
+  background-image: linear-gradient(to bottom, #149bdf, #0480be);
+  background-repeat: repeat-x;
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff149bdf', endColorstr='#ff0480be', GradientType=0);
+  -webkit-box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.15);
+  -moz-box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.15);
+  box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.15);
+  -webkit-box-sizing: border-box;
+  -moz-box-sizing: border-box;
+  box-sizing: border-box;
+  -webkit-transition: width 0.6s ease;
+  -moz-transition: width 0.6s ease;
+  -o-transition: width 0.6s ease;
+  transition: width 0.6s ease;
+}
+.progress .bar + .bar {
+  -webkit-box-shadow: inset 1px 0 0 rgba(0,0,0,.15), inset 0 -1px 0 rgba(0,0,0,.15);
+  -moz-box-shadow: inset 1px 0 0 rgba(0,0,0,.15), inset 0 -1px 0 rgba(0,0,0,.15);
+  box-shadow: inset 1px 0 0 rgba(0,0,0,.15), inset 0 -1px 0 rgba(0,0,0,.15);
+}
+.progress-striped .bar {
+  background-color: #149bdf;
+  background-image: -webkit-gradient(linear, 0 100%, 100% 0, color-stop(0.25, rgba(255, 255, 255, 0.15)), color-stop(0.25, transparent), color-stop(0.5, transparent), color-stop(0.5, rgba(255, 255, 255, 0.15)), color-stop(0.75, rgba(255, 255, 255, 0.15)), color-stop(0.75, transparent), to(transparent));
+  background-image: -webkit-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+  background-image: -moz-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+  background-image: -o-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+  background-image: linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+  -webkit-background-size: 40px 40px;
+  -moz-background-size: 40px 40px;
+  -o-background-size: 40px 40px;
+  background-size: 40px 40px;
+}
+.progress.active .bar {
+  -webkit-animation: progress-bar-stripes 2s linear infinite;
+  -moz-animation: progress-bar-stripes 2s linear infinite;
+  -ms-animation: progress-bar-stripes 2s linear infinite;
+  -o-animation: progress-bar-stripes 2s linear infinite;
+  animation: progress-bar-stripes 2s linear infinite;
+}
+.progress-danger .bar,
+.progress .bar-danger {
+  background-color: #dd514c;
+  background-image: -moz-linear-gradient(top, #ee5f5b, #c43c35);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#ee5f5b), to(#c43c35));
+  background-image: -webkit-linear-gradient(top, #ee5f5b, #c43c35);
+  background-image: -o-linear-gradient(top, #ee5f5b, #c43c35);
+  background-image: linear-gradient(to bottom, #ee5f5b, #c43c35);
+  background-repeat: repeat-x;
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffee5f5b', endColorstr='#ffc43c35', GradientType=0);
+}
+.progress-danger.progress-striped .bar,
+.progress-striped .bar-danger {
+  background-color: #ee5f5b;
+  background-image: -webkit-gradient(linear, 0 100%, 100% 0, color-stop(0.25, rgba(255, 255, 255, 0.15)), color-stop(0.25, transparent), color-stop(0.5, transparent), color-stop(0.5, rgba(255, 255, 255, 0.15)), color-stop(0.75, rgba(255, 255, 255, 0.15)), color-stop(0.75, transparent), to(transparent));
+  background-image: -webkit-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+  background-image: -moz-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+  background-image: -o-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+  background-image: linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+}
+.progress-success .bar,
+.progress .bar-success {
+  background-color: #5eb95e;
+  background-image: -moz-linear-gradient(top, #62c462, #57a957);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#62c462), to(#57a957));
+  background-image: -webkit-linear-gradient(top, #62c462, #57a957);
+  background-image: -o-linear-gradient(top, #62c462, #57a957);
+  background-image: linear-gradient(to bottom, #62c462, #57a957);
+  background-repeat: repeat-x;
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff62c462', endColorstr='#ff57a957', GradientType=0);
+}
+.progress-success.progress-striped .bar,
+.progress-striped .bar-success {
+  background-color: #62c462;
+  background-image: -webkit-gradient(linear, 0 100%, 100% 0, color-stop(0.25, rgba(255, 255, 255, 0.15)), color-stop(0.25, transparent), color-stop(0.5, transparent), color-stop(0.5, rgba(255, 255, 255, 0.15)), color-stop(0.75, rgba(255, 255, 255, 0.15)), color-stop(0.75, transparent), to(transparent));
+  background-image: -webkit-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+  background-image: -moz-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+  background-image: -o-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+  background-image: linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+}
+.progress-info .bar,
+.progress .bar-info {
+  background-color: #4bb1cf;
+  background-image: -moz-linear-gradient(top, #5bc0de, #339bb9);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#5bc0de), to(#339bb9));
+  background-image: -webkit-linear-gradient(top, #5bc0de, #339bb9);
+  background-image: -o-linear-gradient(top, #5bc0de, #339bb9);
+  background-image: linear-gradient(to bottom, #5bc0de, #339bb9);
+  background-repeat: repeat-x;
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff5bc0de', endColorstr='#ff339bb9', GradientType=0);
+}
+.progress-info.progress-striped .bar,
+.progress-striped .bar-info {
+  background-color: #5bc0de;
+  background-image: -webkit-gradient(linear, 0 100%, 100% 0, color-stop(0.25, rgba(255, 255, 255, 0.15)), color-stop(0.25, transparent), color-stop(0.5, transparent), color-stop(0.5, rgba(255, 255, 255, 0.15)), color-stop(0.75, rgba(255, 255, 255, 0.15)), color-stop(0.75, transparent), to(transparent));
+  background-image: -webkit-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+  background-image: -moz-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+  background-image: -o-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+  background-image: linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+}
+.progress-warning .bar,
+.progress .bar-warning {
+  background-color: #faa732;
+  background-image: -moz-linear-gradient(top, #fbb450, #f89406);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#fbb450), to(#f89406));
+  background-image: -webkit-linear-gradient(top, #fbb450, #f89406);
+  background-image: -o-linear-gradient(top, #fbb450, #f89406);
+  background-image: linear-gradient(to bottom, #fbb450, #f89406);
+  background-repeat: repeat-x;
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fffbb450', endColorstr='#fff89406', GradientType=0);
+}
+.progress-warning.progress-striped .bar,
+.progress-striped .bar-warning {
+  background-color: #fbb450;
+  background-image: -webkit-gradient(linear, 0 100%, 100% 0, color-stop(0.25, rgba(255, 255, 255, 0.15)), color-stop(0.25, transparent), color-stop(0.5, transparent), color-stop(0.5, rgba(255, 255, 255, 0.15)), color-stop(0.75, rgba(255, 255, 255, 0.15)), color-stop(0.75, transparent), to(transparent));
+  background-image: -webkit-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+  background-image: -moz-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+  background-image: -o-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+  background-image: linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
+}
+.hero-unit {
+  padding: 60px;
+  margin-bottom: 30px;
+  font-size: 18px;
+  font-weight: 200;
+  line-height: 30px;
+  color: inherit;
+  background-color: #eeeeee;
+  -webkit-border-radius: 6px;
+  -moz-border-radius: 6px;
+  border-radius: 6px;
+}
+.hero-unit h1 {
+  margin-bottom: 0;
+  font-size: 60px;
+  line-height: 1;
+  color: inherit;
+  letter-spacing: -1px;
+}
+.hero-unit li {
+  line-height: 30px;
+}
+.media,
+.media-body {
+  overflow: hidden;
+  *overflow: visible;
+  zoom: 1;
+}
+.media,
+.media .media {
+  margin-top: 15px;
+}
+.media:first-child {
+  margin-top: 0;
+}
+.media-object {
+  display: block;
+}
+.media-heading {
+  margin: 0 0 5px;
+}
+.media > .pull-left {
+  margin-right: 10px;
+}
+.media > .pull-right {
+  margin-left: 10px;
+}
+.media-list {
+  margin-left: 0;
+  list-style: none;
+}
+.tooltip {
+  position: absolute;
+  z-index: 1030;
+  display: block;
+  visibility: visible;
+  font-size: 11px;
+  line-height: 1.4;
+  opacity: 0;
+  filter: alpha(opacity=0);
+}
+.tooltip.in {
+  opacity: 0.8;
+  filter: alpha(opacity=80);
+}
+.tooltip.top {
+  margin-top: -3px;
+  padding: 5px 0;
+}
+.tooltip.right {
+  margin-left: 3px;
+  padding: 0 5px;
+}
+.tooltip.bottom {
+  margin-top: 3px;
+  padding: 5px 0;
+}
+.tooltip.left {
+  margin-left: -3px;
+  padding: 0 5px;
+}
+.tooltip-inner {
+  max-width: 200px;
+  padding: 8px;
+  color: #ffffff;
+  text-align: center;
+  text-decoration: none;
+  background-color: #000000;
+  -webkit-border-radius: 4px;
+  -moz-border-radius: 4px;
+  border-radius: 4px;
+}
+.tooltip-arrow {
+  position: absolute;
+  width: 0;
+  height: 0;
+  border-color: transparent;
+  border-style: solid;
+}
+.tooltip.top .tooltip-arrow {
+  bottom: 0;
+  left: 50%;
+  margin-left: -5px;
+  border-width: 5px 5px 0;
+  border-top-color: #000000;
+}
+.tooltip.right .tooltip-arrow {
+  top: 50%;
+  left: 0;
+  margin-top: -5px;
+  border-width: 5px 5px 5px 0;
+  border-right-color: #000000;
+}
+.tooltip.left .tooltip-arrow {
+  top: 50%;
+  right: 0;
+  margin-top: -5px;
+  border-width: 5px 0 5px 5px;
+  border-left-color: #000000;
+}
+.tooltip.bottom .tooltip-arrow {
+  top: 0;
+  left: 50%;
+  margin-left: -5px;
+  border-width: 0 5px 5px;
+  border-bottom-color: #000000;
+}
+.popover {
+  position: absolute;
+  top: 0;
+  left: 0;
+  z-index: 1010;
+  display: none;
+  max-width: 276px;
+  padding: 1px;
+  text-align: left;
+  background-color: #ffffff;
+  -webkit-background-clip: padding-box;
+  -moz-background-clip: padding;
+  background-clip: padding-box;
+  border: 1px solid #ccc;
+  border: 1px solid rgba(0, 0, 0, 0.2);
+  -webkit-border-radius: 6px;
+  -moz-border-radius: 6px;
+  border-radius: 6px;
+  -webkit-box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
+  -moz-box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
+  box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
+  white-space: normal;
+}
+.popover.top {
+  margin-top: -10px;
+}
+.popover.right {
+  margin-left: 10px;
+}
+.popover.bottom {
+  margin-top: 10px;
+}
+.popover.left {
+  margin-left: -10px;
+}
+.popover-title {
+  margin: 0;
+  padding: 8px 14px;
+  font-size: 14px;
+  font-weight: normal;
+  line-height: 18px;
+  background-color: #f7f7f7;
+  border-bottom: 1px solid #ebebeb;
+  -webkit-border-radius: 5px 5px 0 0;
+  -moz-border-radius: 5px 5px 0 0;
+  border-radius: 5px 5px 0 0;
+}
+.popover-title:empty {
+  display: none;
+}
+.popover-content {
+  padding: 9px 14px;
+}
+.popover .arrow,
+.popover .arrow:after {
+  position: absolute;
+  display: block;
+  width: 0;
+  height: 0;
+  border-color: transparent;
+  border-style: solid;
+}
+.popover .arrow {
+  border-width: 11px;
+}
+.popover .arrow:after {
+  border-width: 10px;
+  content: "";
+}
+.popover.top .arrow {
+  left: 50%;
+  margin-left: -11px;
+  border-bottom-width: 0;
+  border-top-color: #999;
+  border-top-color: rgba(0, 0, 0, 0.25);
+  bottom: -11px;
+}
+.popover.top .arrow:after {
+  bottom: 1px;
+  margin-left: -10px;
+  border-bottom-width: 0;
+  border-top-color: #ffffff;
+}
+.popover.right .arrow {
+  top: 50%;
+  left: -11px;
+  margin-top: -11px;
+  border-left-width: 0;
+  border-right-color: #999;
+  border-right-color: rgba(0, 0, 0, 0.25);
+}
+.popover.right .arrow:after {
+  left: 1px;
+  bottom: -10px;
+  border-left-width: 0;
+  border-right-color: #ffffff;
+}
+.popover.bottom .arrow {
+  left: 50%;
+  margin-left: -11px;
+  border-top-width: 0;
+  border-bottom-color: #999;
+  border-bottom-color: rgba(0, 0, 0, 0.25);
+  top: -11px;
+}
+.popover.bottom .arrow:after {
+  top: 1px;
+  margin-left: -10px;
+  border-top-width: 0;
+  border-bottom-color: #ffffff;
+}
+.popover.left .arrow {
+  top: 50%;
+  right: -11px;
+  margin-top: -11px;
+  border-right-width: 0;
+  border-left-color: #999;
+  border-left-color: rgba(0, 0, 0, 0.25);
+}
+.popover.left .arrow:after {
+  right: 1px;
+  border-right-width: 0;
+  border-left-color: #ffffff;
+  bottom: -10px;
+}
+.modal-backdrop {
+  position: fixed;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  z-index: 1040;
+  background-color: #000000;
+}
+.modal-backdrop.fade {
+  opacity: 0;
+}
+.modal-backdrop,
+.modal-backdrop.fade.in {
+  opacity: 0.8;
+  filter: alpha(opacity=80);
+}
+.modal {
+  position: fixed;
+  top: 10%;
+  left: 50%;
+  z-index: 1050;
+  width: 560px;
+  margin-left: -280px;
+  background-color: #ffffff;
+  border: 1px solid #999;
+  border: 1px solid rgba(0, 0, 0, 0.3);
+  *border: 1px solid #999;
+  /* IE6-7 */
+
+  -webkit-border-radius: 6px;
+  -moz-border-radius: 6px;
+  border-radius: 6px;
+  -webkit-box-shadow: 0 3px 7px rgba(0, 0, 0, 0.3);
+  -moz-box-shadow: 0 3px 7px rgba(0, 0, 0, 0.3);
+  box-shadow: 0 3px 7px rgba(0, 0, 0, 0.3);
+  -webkit-background-clip: padding-box;
+  -moz-background-clip: padding-box;
+  background-clip: padding-box;
+  outline: none;
+}
+.modal.fade {
+  -webkit-transition: opacity .3s linear, top .3s ease-out;
+  -moz-transition: opacity .3s linear, top .3s ease-out;
+  -o-transition: opacity .3s linear, top .3s ease-out;
+  transition: opacity .3s linear, top .3s ease-out;
+  top: -25%;
+}
+.modal.fade.in {
+  top: 10%;
+}
+.modal-header {
+  padding: 9px 15px;
+  border-bottom: 1px solid #eee;
+}
+.modal-header .close {
+  margin-top: 2px;
+}
+.modal-header h3 {
+  margin: 0;
+  line-height: 30px;
+}
+.modal-body {
+  position: relative;
+  overflow-y: auto;
+  max-height: 400px;
+  padding: 15px;
+}
+.modal-form {
+  margin-bottom: 0;
+}
+.modal-footer {
+  padding: 14px 15px 15px;
+  margin-bottom: 0;
+  text-align: right;
+  background-color: #f5f5f5;
+  border-top: 1px solid #ddd;
+  -webkit-border-radius: 0 0 6px 6px;
+  -moz-border-radius: 0 0 6px 6px;
+  border-radius: 0 0 6px 6px;
+  -webkit-box-shadow: inset 0 1px 0 #ffffff;
+  -moz-box-shadow: inset 0 1px 0 #ffffff;
+  box-shadow: inset 0 1px 0 #ffffff;
+  *zoom: 1;
+}
+.modal-footer:before,
+.modal-footer:after {
+  display: table;
+  content: "";
+  line-height: 0;
+}
+.modal-footer:after {
+  clear: both;
+}
+.modal-footer .btn + .btn {
+  margin-left: 5px;
+  margin-bottom: 0;
+}
+.modal-footer .btn-group .btn + .btn {
+  margin-left: -1px;
+}
+.modal-footer .btn-block + .btn-block {
+  margin-left: 0;
+}
+.dropup,
+.dropdown {
+  position: relative;
+}
+.dropdown-toggle {
+  *margin-bottom: -3px;
+}
+.dropdown-toggle:active,
+.open .dropdown-toggle {
+  outline: 0;
+}
+.caret {
+  display: inline-block;
+  width: 0;
+  height: 0;
+  vertical-align: top;
+  border-top: 4px solid #000000;
+  border-right: 4px solid transparent;
+  border-left: 4px solid transparent;
+  content: "";
+}
+.dropdown .caret {
+  margin-top: 8px;
+  margin-left: 2px;
+}
+.dropdown-menu {
+  position: absolute;
+  top: 100%;
+  left: 0;
+  z-index: 1000;
+  display: none;
+  float: left;
+  min-width: 160px;
+  padding: 5px 0;
+  margin: 2px 0 0;
+  list-style: none;
+  background-color: #ffffff;
+  border: 1px solid #ccc;
+  border: 1px solid rgba(0, 0, 0, 0.2);
+  *border-right-width: 2px;
+  *border-bottom-width: 2px;
+  -webkit-border-radius: 6px;
+  -moz-border-radius: 6px;
+  border-radius: 6px;
+  -webkit-box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
+  -moz-box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
+  box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
+  -webkit-background-clip: padding-box;
+  -moz-background-clip: padding;
+  background-clip: padding-box;
+}
+.dropdown-menu.pull-right {
+  right: 0;
+  left: auto;
+}
+.dropdown-menu .divider {
+  *width: 100%;
+  height: 1px;
+  margin: 9px 1px;
+  *margin: -5px 0 5px;
+  overflow: hidden;
+  background-color: #e5e5e5;
+  border-bottom: 1px solid #ffffff;
+}
+.dropdown-menu > li > a {
+  display: block;
+  padding: 3px 20px;
+  clear: both;
+  font-weight: normal;
+  line-height: 20px;
+  color: #333333;
+  white-space: nowrap;
+}
+.dropdown-menu > li > a:hover,
+.dropdown-menu > li > a:focus,
+.dropdown-submenu:hover > a,
+.dropdown-submenu:focus > a {
+  text-decoration: none;
+  color: #ffffff;
+  background-color: #0081c2;
+  background-image: -moz-linear-gradient(top, #0088cc, #0077b3);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#0088cc), to(#0077b3));
+  background-image: -webkit-linear-gradient(top, #0088cc, #0077b3);
+  background-image: -o-linear-gradient(top, #0088cc, #0077b3);
+  background-image: linear-gradient(to bottom, #0088cc, #0077b3);
+  background-repeat: repeat-x;
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff0088cc', endColorstr='#ff0077b3', GradientType=0);
+}
+.dropdown-menu > .active > a,
+.dropdown-menu > .active > a:hover,
+.dropdown-menu > .active > a:focus {
+  color: #ffffff;
+  text-decoration: none;
+  outline: 0;
+  background-color: #0081c2;
+  background-image: -moz-linear-gradient(top, #0088cc, #0077b3);
+  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#0088cc), to(#0077b3));
+  background-image: -webkit-linear-gradient(top, #0088cc, #0077b3);
+  background-image: -o-linear-gradient(top, #0088cc, #0077b3);
+  background-image: linear-gradient(to bottom, #0088cc, #0077b3);
+  background-repeat: repeat-x;
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff0088cc', endColorstr='#ff0077b3', GradientType=0);
+}
+.dropdown-menu > .disabled > a,
+.dropdown-menu > .disabled > a:hover,
+.dropdown-menu > .disabled > a:focus {
+  color: #999999;
+}
+.dropdown-menu > .disabled > a:hover,
+.dropdown-menu > .disabled > a:focus {
+  text-decoration: none;
+  background-color: transparent;
+  background-image: none;
+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
+  cursor: default;
+}
+.open {
+  *z-index: 1000;
+}
+.open > .dropdown-menu {
+  display: block;
+}
+.pull-right > .dropdown-menu {
+  right: 0;
+  left: auto;
+}
+.dropup .caret,
+.navbar-fixed-bottom .dropdown .caret {
+  border-top: 0;
+  border-bottom: 4px solid #000000;
+  content: "";
+}
+.dropup .dropdown-menu,
+.navbar-fixed-bottom .dropdown .dropdown-menu {
+  top: auto;
+  bottom: 100%;
+  margin-bottom: 1px;
+}
+.dropdown-submenu {
+  position: relative;
+}
+.dropdown-submenu > .dropdown-menu {
+  top: 0;
+  left: 100%;
+  margin-top: -6px;
+  margin-left: -1px;
+  -webkit-border-radius: 0 6px 6px 6px;
+  -moz-border-radius: 0 6px 6px 6px;
+  border-radius: 0 6px 6px 6px;
+}
+.dropdown-submenu:hover > .dropdown-menu {
+  display: block;
+}
+.dropup .dropdown-submenu > .dropdown-menu {
+  top: auto;
+  bottom: 0;
+  margin-top: 0;
+  margin-bottom: -2px;
+  -webkit-border-radius: 5px 5px 5px 0;
+  -moz-border-radius: 5px 5px 5px 0;
+  border-radius: 5px 5px 5px 0;
+}
+.dropdown-submenu > a:after {
+  display: block;
+  content: " ";
+  float: right;
+  width: 0;
+  height: 0;
+  border-color: transparent;
+  border-style: solid;
+  border-width: 5px 0 5px 5px;
+  border-left-color: #cccccc;
+  margin-top: 5px;
+  margin-right: -10px;
+}
+.dropdown-submenu:hover > a:after {
+  border-left-color: #ffffff;
+}
+.dropdown-submenu.pull-left {
+  float: none;
+}
+.dropdown-submenu.pull-left > .dropdown-menu {
+  left: -100%;
+  margin-left: 10px;
+  -webkit-border-radius: 6px 0 6px 6px;
+  -moz-border-radius: 6px 0 6px 6px;
+  border-radius: 6px 0 6px 6px;
+}
+.dropdown .dropdown-menu .nav-header {
+  padding-left: 20px;
+  padding-right: 20px;
+}
+.typeahead {
+  z-index: 1051;
+  margin-top: 2px;
+  -webkit-border-radius: 4px;
+  -moz-border-radius: 4px;
+  border-radius: 4px;
+}
+.accordion {
+  margin-bottom: 20px;
+}
+.accordion-group {
+  margin-bottom: 2px;
+  border: 1px solid #e5e5e5;
+  -webkit-border-radius: 4px;
+  -moz-border-radius: 4px;
+  border-radius: 4px;
+}
+.accordion-heading {
+  border-bottom: 0;
+}
+.accordion-heading .accordion-toggle {
+  display: block;
+  padding: 8px 15px;
+}
+.accordion-toggle {
+  cursor: pointer;
+}
+.accordion-inner {
+  padding: 9px 15px;
+  border-top: 1px solid #e5e5e5;
+}
+.carousel {
+  position: relative;
+  margin-bottom: 20px;
+  line-height: 1;
+}
+.carousel-inner {
+  overflow: hidden;
+  width: 100%;
+  position: relative;
+}
+.carousel-inner > .item {
+  display: none;
+  position: relative;
+  -webkit-transition: 0.6s ease-in-out left;
+  -moz-transition: 0.6s ease-in-out left;
+  -o-transition: 0.6s ease-in-out left;
+  transition: 0.6s ease-in-out left;
+}
+.carousel-inner > .item > img,
+.carousel-inner > .item > a > img {
+  display: block;
+  line-height: 1;
+}
+.carousel-inner > .active,
+.carousel-inner > .next,
+.carousel-inner > .prev {
+  display: block;
+}
+.carousel-inner > .active {
+  left: 0;
+}
+.carousel-inner > .next,
+.carousel-inner > .prev {
+  position: absolute;
+  top: 0;
+  width: 100%;
+}
+.carousel-inner > .next {
+  left: 100%;
+}
+.carousel-inner > .prev {
+  left: -100%;
+}
+.carousel-inner > .next.left,
+.carousel-inner > .prev.right {
+  left: 0;
+}
+.carousel-inner > .active.left {
+  left: -100%;
+}
+.carousel-inner > .active.right {
+  left: 100%;
+}
+.carousel-control {
+  position: absolute;
+  top: 40%;
+  left: 15px;
+  width: 40px;
+  height: 40px;
+  margin-top: -20px;
+  font-size: 60px;
+  font-weight: 100;
+  line-height: 30px;
+  color: #ffffff;
+  text-align: center;
+  background: #222222;
+  border: 3px solid #ffffff;
+  -webkit-border-radius: 23px;
+  -moz-border-radius: 23px;
+  border-radius: 23px;
+  opacity: 0.5;
+  filter: alpha(opacity=50);
+}
+.carousel-control.right {
+  left: auto;
+  right: 15px;
+}
+.carousel-control:hover,
+.carousel-control:focus {
+  color: #ffffff;
+  text-decoration: none;
+  opacity: 0.9;
+  filter: alpha(opacity=90);
+}
+.carousel-indicators {
+  position: absolute;
+  top: 15px;
+  right: 15px;
+  z-index: 5;
+  margin: 0;
+  list-style: none;
+}
+.carousel-indicators li {
+  display: block;
+  float: left;
+  width: 10px;
+  height: 10px;
+  margin-left: 5px;
+  text-indent: -999px;
+  background-color: #ccc;
+  background-color: rgba(255, 255, 255, 0.25);
+  border-radius: 5px;
+}
+.carousel-indicators .active {
+  background-color: #fff;
+}
+.carousel-caption {
+  position: absolute;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  padding: 15px;
+  background: #333333;
+  background: rgba(0, 0, 0, 0.75);
+}
+.carousel-caption h4,
+.carousel-caption p {
+  color: #ffffff;
+  line-height: 20px;
+}
+.carousel-caption h4 {
+  margin: 0 0 5px;
+}
+.carousel-caption p {
+  margin-bottom: 0;
+}
+.well {
+  min-height: 20px;
+  padding: 19px;
+  margin-bottom: 20px;
+  background-color: #f5f5f5;
+  border: 1px solid #e3e3e3;
+  -webkit-border-radius: 4px;
+  -moz-border-radius: 4px;
+  border-radius: 4px;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.05);
+  -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.05);
+  box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.05);
+}
+.well blockquote {
+  border-color: #ddd;
+  border-color: rgba(0, 0, 0, 0.15);
+}
+.well-large {
+  padding: 24px;
+  -webkit-border-radius: 6px;
+  -moz-border-radius: 6px;
+  border-radius: 6px;
+}
+.well-small {
+  padding: 9px;
+  -webkit-border-radius: 3px;
+  -moz-border-radius: 3px;
+  border-radius: 3px;
+}
+.close {
+  float: right;
+  font-size: 20px;
+  font-weight: bold;
+  line-height: 20px;
+  color: #000000;
+  text-shadow: 0 1px 0 #ffffff;
+  opacity: 0.2;
+  filter: alpha(opacity=20);
+}
+.close:hover,
+.close:focus {
+  color: #000000;
+  text-decoration: none;
+  cursor: pointer;
+  opacity: 0.4;
+  filter: alpha(opacity=40);
+}
+button.close {
+  padding: 0;
+  cursor: pointer;
+  background: transparent;
+  border: 0;
+  -webkit-appearance: none;
+}
+.pull-right {
+  float: right;
+}
+.pull-left {
+  float: left;
+}
+.hide {
+  display: none;
+}
+.show {
+  display: block;
+}
+.invisible {
+  visibility: hidden;
+}
+.affix {
+  position: fixed;
+}
+.fade {
+  opacity: 0;
+  -webkit-transition: opacity 0.15s linear;
+  -moz-transition: opacity 0.15s linear;
+  -o-transition: opacity 0.15s linear;
+  transition: opacity 0.15s linear;
+}
+.fade.in {
+  opacity: 1;
+}
+.collapse {
+  position: relative;
+  height: 0;
+  overflow: hidden;
+  -webkit-transition: height 0.35s ease;
+  -moz-transition: height 0.35s ease;
+  -o-transition: height 0.35s ease;
+  transition: height 0.35s ease;
+}
+.collapse.in {
+  height: auto;
+}
+@-ms-viewport {
+  width: device-width;
+}
+.hidden {
+  display: none;
+  visibility: hidden;
+}
+.visible-phone {
+  display: none !important;
+}
+.visible-tablet {
+  display: none !important;
+}
+.hidden-desktop {
+  display: none !important;
+}
+.visible-desktop {
+  display: inherit !important;
+}
+@media (min-width: 768px) and (max-width: 979px) {
+  .hidden-desktop {
+    display: inherit !important;
+  }
+  .visible-desktop {
+    display: none !important ;
+  }
+  .visible-tablet {
+    display: inherit !important;
+  }
+  .hidden-tablet {
+    display: none !important;
+  }
+}
+@media (max-width: 767px) {
+  .hidden-desktop {
+    display: inherit !important;
+  }
+  .visible-desktop {
+    display: none !important;
+  }
+  .visible-phone {
+    display: inherit !important;
+  }
+  .hidden-phone {
+    display: none !important;
+  }
+}
+.visible-print {
+  display: none !important;
+}
+@media print {
+  .visible-print {
+    display: inherit !important;
+  }
+  .hidden-print {
+    display: none !important;
+  }
+}
+@media (max-width: 767px) {
+  body {
+    padding-left: 20px;
+    padding-right: 20px;
+  }
+  .navbar-fixed-top,
+  .navbar-fixed-bottom,
+  .navbar-static-top {
+    margin-left: -20px;
+    margin-right: -20px;
+  }
+  .container-fluid {
+    padding: 0;
+  }
+  .dl-horizontal dt {
+    float: none;
+    clear: none;
+    width: auto;
+    text-align: left;
+  }
+  .dl-horizontal dd {
+    margin-left: 0;
+  }
+  .container {
+    width: auto;
+  }
+  .row-fluid {
+    width: 100%;
+  }
+  .row,
+  .thumbnails {
+    margin-left: 0;
+  }
+  .thumbnails > li {
+    float: none;
+    margin-left: 0;
+  }
+  [class*="span"],
+  .uneditable-input[class*="span"],
+  .row-fluid [class*="span"] {
+    float: none;
+    display: block;
+    width: 100%;
+    margin-left: 0;
+    -webkit-box-sizing: border-box;
+    -moz-box-sizing: border-box;
+    box-sizing: border-box;
+  }
+  .span12,
+  .row-fluid .span12 {
+    width: 100%;
+    -webkit-box-sizing: border-box;
+    -moz-box-sizing: border-box;
+    box-sizing: border-box;
+  }
+  .row-fluid [class*="offset"]:first-child {
+    margin-left: 0;
+  }
+  .input-large,
+  .input-xlarge,
+  .input-xxlarge,
+  input[class*="span"],
+  select[class*="span"],
+  textarea[class*="span"],
+  .uneditable-input {
+    display: block;
+    width: 100%;
+    min-height: 30px;
+    -webkit-box-sizing: border-box;
+    -moz-box-sizing: border-box;
+    box-sizing: border-box;
+  }
+  .input-prepend input,
+  .input-append input,
+  .input-prepend input[class*="span"],
+  .input-append input[class*="span"] {
+    display: inline-block;
+    width: auto;
+  }
+  .controls-row [class*="span"] + [class*="span"] {
+    margin-left: 0;
+  }
+  .modal {
+    position: fixed;
+    top: 20px;
+    left: 20px;
+    right: 20px;
+    width: auto;
+    margin: 0;
+  }
+  .modal.fade {
+    top: -100px;
+  }
+  .modal.fade.in {
+    top: 20px;
+  }
+}
+@media (max-width: 480px) {
+  .nav-collapse {
+    -webkit-transform: translate3d(0, 0, 0);
+  }
+  .page-header h1 small {
+    display: block;
+    line-height: 20px;
+  }
+  input[type="checkbox"],
+  input[type="radio"] {
+    border: 1px solid #ccc;
+  }
+  .form-horizontal .control-label {
+    float: none;
+    width: auto;
+    padding-top: 0;
+    text-align: left;
+  }
+  .form-horizontal .controls {
+    margin-left: 0;
+  }
+  .form-horizontal .control-list {
+    padding-top: 0;
+  }
+  .form-horizontal .form-actions {
+    padding-left: 10px;
+    padding-right: 10px;
+  }
+  .media .pull-left,
+  .media .pull-right {
+    float: none;
+    display: block;
+    margin-bottom: 10px;
+  }
+  .media-object {
+    margin-right: 0;
+    margin-left: 0;
+  }
+  .modal {
+    top: 10px;
+    left: 10px;
+    right: 10px;
+  }
+  .modal-header .close {
+    padding: 10px;
+    margin: -10px;
+  }
+  .carousel-caption {
+    position: static;
+  }
+}
+@media (min-width: 768px) and (max-width: 979px) {
+  .row {
+    margin-left: -20px;
+    *zoom: 1;
+  }
+  .row:before,
+  .row:after {
+    display: table;
+    content: "";
+    line-height: 0;
+  }
+  .row:after {
+    clear: both;
+  }
+  [class*="span"] {
+    float: left;
+    min-height: 1px;
+    margin-left: 20px;
+  }
+  .container,
+  .navbar-static-top .container,
+  .navbar-fixed-top .container,
+  .navbar-fixed-bottom .container {
+    width: 724px;
+  }
+  .span12 {
+    width: 724px;
+  }
+  .span11 {
+    width: 662px;
+  }
+  .span10 {
+    width: 600px;
+  }
+  .span9 {
+    width: 538px;
+  }
+  .span8 {
+    width: 476px;
+  }
+  .span7 {
+    width: 414px;
+  }
+  .span6 {
+    width: 352px;
+  }
+  .span5 {
+    width: 290px;
+  }
+  .span4 {
+    width: 228px;
+  }
+  .span3 {
+    width: 166px;
+  }
+  .span2 {
+    width: 104px;
+  }
+  .span1 {
+    width: 42px;
+  }
+  .offset12 {
+    margin-left: 764px;
+  }
+  .offset11 {
+    margin-left: 702px;
+  }
+  .offset10 {
+    margin-left: 640px;
+  }
+  .offset9 {
+    margin-left: 578px;
+  }
+  .offset8 {
+    margin-left: 516px;
+  }
+  .offset7 {
+    margin-left: 454px;
+  }
+  .offset6 {
+    margin-left: 392px;
+  }
+  .offset5 {
+    margin-left: 330px;
+  }
+  .offset4 {
+    margin-left: 268px;
+  }
+  .offset3 {
+    margin-left: 206px;
+  }
+  .offset2 {
+    margin-left: 144px;
+  }
+  .offset1 {
+    margin-left: 82px;
+  }
+  .row-fluid {
+    width: 100%;
+    *zoom: 1;
+  }
+  .row-fluid:before,
+  .row-fluid:after {
+    display: table;
+    content: "";
+    line-height: 0;
+  }
+  .row-fluid:after {
+    clear: both;
+  }
+  .row-fluid [class*="span"] {
+    display: block;
+    width: 100%;
+    min-height: 30px;
+    -webkit-box-sizing: border-box;
+    -moz-box-sizing: border-box;
+    box-sizing: border-box;
+    float: left;
+    margin-left: 2.7624309392265194%;
+    *margin-left: 2.709239449864817%;
+  }
+  .row-fluid [class*="span"]:first-child {
+    margin-left: 0;
+  }
+  .row-fluid .controls-row [class*="span"] + [class*="span"] {
+    margin-left: 2.7624309392265194%;
+  }
+  .row-fluid .span12 {
+    width: 100%;
+    *width: 99.94680851063829%;
+  }
+  .row-fluid .span11 {
+    width: 91.43646408839778%;
+    *width: 91.38327259903608%;
+  }
+  .row-fluid .span10 {
+    width: 82.87292817679558%;
+    *width: 82.81973668743387%;
+  }
+  .row-fluid .span9 {
+    width: 74.30939226519337%;
+    *width: 74.25620077583166%;
+  }
+  .row-fluid .span8 {
+    width: 65.74585635359117%;
+    *width: 65.69266486422946%;
+  }
+  .row-fluid .span7 {
+    width: 57.18232044198895%;
+    *width: 57.12912895262725%;
+  }
+  .row-fluid .span6 {
+    width: 48.61878453038674%;
+    *width: 48.56559304102504%;
+  }
+  .row-fluid .span5 {
+    width: 40.05524861878453%;
+    *width: 40.00205712942283%;
+  }
+  .row-fluid .span4 {
+    width: 31.491712707182323%;
+    *width: 31.43852121782062%;
+  }
+  .row-fluid .span3 {
+    width: 22.92817679558011%;
+    *width: 22.87498530621841%;
+  }
+  .row-fluid .span2 {
+    width: 14.3646408839779%;
+    *width: 14.311449394616199%;
+  }
+  .row-fluid .span1 {
+    width: 5.801104972375691%;
+    *width: 5.747913483013988%;
+  }
+  .row-fluid .offset12 {
+    margin-left: 105.52486187845304%;
+    *margin-left: 105.41847889972962%;
+  }
+  .row-fluid .offset12:first-child {
+    margin-left: 102.76243093922652%;
+    *margin-left: 102.6560479605031%;
+  }
+  .row-fluid .offset11 {
+    margin-left: 96.96132596685082%;
+    *margin-left: 96.8549429881274%;
+  }
+  .row-fluid .offset11:first-child {
+    margin-left: 94.1988950276243%;
+    *margin-left: 94.09251204890089%;
+  }
+  .row-fluid .offset10 {
+    margin-left: 88.39779005524862%;
+    *margin-left: 88.2914070765252%;
+  }
+  .row-fluid .offset10:first-child {
+    margin-left: 85.6353591160221%;
+    *margin-left: 85.52897613729868%;
+  }
+  .row-fluid .offset9 {
+    margin-left: 79.8342541436464%;
+    *margin-left: 79.72787116492299%;
+  }
+  .row-fluid .offset9:first-child {
+    margin-left: 77.07182320441989%;
+    *margin-left: 76.96544022569647%;
+  }
+  .row-fluid .offset8 {
+    margin-left: 71.2707182320442%;
+    *margin-left: 71.16433525332079%;
+  }
+  .row-fluid .offset8:first-child {
+    margin-left: 68.50828729281768%;
+    *margin-left: 68.40190431409427%;
+  }
+  .row-fluid .offset7 {
+    margin-left: 62.70718232044199%;
+    *margin-left: 62.600799341718584%;
+  }
+  .row-fluid .offset7:first-child {
+    margin-left: 59.94475138121547%;
+    *margin-left: 59.838368402492065%;
+  }
+  .row-fluid .offset6 {
+    margin-left: 54.14364640883978%;
+    *margin-left: 54.037263430116376%;
+  }
+  .row-fluid .offset6:first-child {
+    margin-left: 51.38121546961326%;
+    *margin-left: 51.27483249088986%;
+  }
+  .row-fluid .offset5 {
+    margin-left: 45.58011049723757%;
+    *margin-left: 45.47372751851417%;
+  }
+  .row-fluid .offset5:first-child {
+    margin-left: 42.81767955801105%;
+    *margin-left: 42.71129657928765%;
+  }
+  .row-fluid .offset4 {
+    margin-left: 37.01657458563536%;
+    *margin-left: 36.91019160691196%;
+  }
+  .row-fluid .offset4:first-child {
+    margin-left: 34.25414364640884%;
+    *margin-left: 34.14776066768544%;
+  }
+  .row-fluid .offset3 {
+    margin-left: 28.45303867403315%;
+    *margin-left: 28.346655695309746%;
+  }
+  .row-fluid .offset3:first-child {
+    margin-left: 25.69060773480663%;
+    *margin-left: 25.584224756083227%;
+  }
+  .row-fluid .offset2 {
+    margin-left: 19.88950276243094%;
+    *margin-left: 19.783119783707537%;
+  }
+  .row-fluid .offset2:first-child {
+    margin-left: 17.12707182320442%;
+    *margin-left: 17.02068884448102%;
+  }
+  .row-fluid .offset1 {
+    margin-left: 11.32596685082873%;
+    *margin-left: 11.219583872105325%;
+  }
+  .row-fluid .offset1:first-child {
+    margin-left: 8.56353591160221%;
+    *margin-left: 8.457152932878806%;
+  }
+  input,
+  textarea,
+  .uneditable-input {
+    margin-left: 0;
+  }
+  .controls-row [class*="span"] + [class*="span"] {
+    margin-left: 20px;
+  }
+  input.span12,
+  textarea.span12,
+  .uneditable-input.span12 {
+    width: 710px;
+  }
+  input.span11,
+  textarea.span11,
+  .uneditable-input.span11 {
+    width: 648px;
+  }
+  input.span10,
+  textarea.span10,
+  .uneditable-input.span10 {
+    width: 586px;
+  }
+  input.span9,
+  textarea.span9,
+  .uneditable-input.span9 {
+    width: 524px;
+  }
+  input.span8,
+  textarea.span8,
+  .uneditable-input.span8 {
+    width: 462px;
+  }
+  input.span7,
+  textarea.span7,
+  .uneditable-input.span7 {
+    width: 400px;
+  }
+  input.span6,
+  textarea.span6,
+  .uneditable-input.span6 {
+    width: 338px;
+  }
+  input.span5,
+  textarea.span5,
+  .uneditable-input.span5 {
+    width: 276px;
+  }
+  input.span4,
+  textarea.span4,
+  .uneditable-input.span4 {
+    width: 214px;
+  }
+  input.span3,
+  textarea.span3,
+  .uneditable-input.span3 {
+    width: 152px;
+  }
+  input.span2,
+  textarea.span2,
+  .uneditable-input.span2 {
+    width: 90px;
+  }
+  input.span1,
+  textarea.span1,
+  .uneditable-input.span1 {
+    width: 28px;
+  }
+}
+@media (min-width: 1200px) {
+  .row {
+    margin-left: -30px;
+    *zoom: 1;
+  }
+  .row:before,
+  .row:after {
+    display: table;
+    content: "";
+    line-height: 0;
+  }
+  .row:after {
+    clear: both;
+  }
+  [class*="span"] {
+    float: left;
+    min-height: 1px;
+    margin-left: 30px;
+  }
+  .container,
+  .navbar-static-top .container,
+  .navbar-fixed-top .container,
+  .navbar-fixed-bottom .container {
+    width: 1170px;
+  }
+  .span12 {
+    width: 1170px;
+  }
+  .span11 {
+    width: 1070px;
+  }
+  .span10 {
+    width: 970px;
+  }
+  .span9 {
+    width: 870px;
+  }
+  .span8 {
+    width: 770px;
+  }
+  .span7 {
+    width: 670px;
+  }
+  .span6 {
+    width: 570px;
+  }
+  .span5 {
+    width: 470px;
+  }
+  .span4 {
+    width: 370px;
+  }
+  .span3 {
+    width: 270px;
+  }
+  .span2 {
+    width: 170px;
+  }
+  .span1 {
+    width: 70px;
+  }
+  .offset12 {
+    margin-left: 1230px;
+  }
+  .offset11 {
+    margin-left: 1130px;
+  }
+  .offset10 {
+    margin-left: 1030px;
+  }
+  .offset9 {
+    margin-left: 930px;
+  }
+  .offset8 {
+    margin-left: 830px;
+  }
+  .offset7 {
+    margin-left: 730px;
+  }
+  .offset6 {
+    margin-left: 630px;
+  }
+  .offset5 {
+    margin-left: 530px;
+  }
+  .offset4 {
+    margin-left: 430px;
+  }
+  .offset3 {
+    margin-left: 330px;
+  }
+  .offset2 {
+    margin-left: 230px;
+  }
+  .offset1 {
+    margin-left: 130px;
+  }
+  .row-fluid {
+    width: 100%;
+    *zoom: 1;
+  }
+  .row-fluid:before,
+  .row-fluid:after {
+    display: table;
+    content: "";
+    line-height: 0;
+  }
+  .row-fluid:after {
+    clear: both;
+  }
+  .row-fluid [class*="span"] {
+    display: block;
+    width: 100%;
+    min-height: 30px;
+    -webkit-box-sizing: border-box;
+    -moz-box-sizing: border-box;
+    box-sizing: border-box;
+    float: left;
+    margin-left: 2.564102564102564%;
+    *margin-left: 2.5109110747408616%;
+  }
+  .row-fluid [class*="span"]:first-child {
+    margin-left: 0;
+  }
+  .row-fluid .controls-row [class*="span"] + [class*="span"] {
+    margin-left: 2.564102564102564%;
+  }
+  .row-fluid .span12 {
+    width: 100%;
+    *width: 99.94680851063829%;
+  }
+  .row-fluid .span11 {
+    width: 91.45299145299145%;
+    *width: 91.39979996362975%;
+  }
+  .row-fluid .span10 {
+    width: 82.90598290598291%;
+    *width: 82.8527914166212%;
+  }
+  .row-fluid .span9 {
+    width: 74.35897435897436%;
+    *width: 74.30578286961266%;
+  }
+  .row-fluid .span8 {
+    width: 65.81196581196582%;
+    *width: 65.75877432260411%;
+  }
+  .row-fluid .span7 {
+    width: 57.26495726495726%;
+    *width: 57.21176577559556%;
+  }
+  .row-fluid .span6 {
+    width: 48.717948717948715%;
+    *width: 48.664757228587014%;
+  }
+  .row-fluid .span5 {
+    width: 40.17094017094017%;
+    *width: 40.11774868157847%;
+  }
+  .row-fluid .span4 {
+    width: 31.623931623931625%;
+    *width: 31.570740134569924%;
+  }
+  .row-fluid .span3 {
+    width: 23.076923076923077%;
+    *width: 23.023731587561375%;
+  }
+  .row-fluid .span2 {
+    width: 14.52991452991453%;
+    *width: 14.476723040552828%;
+  }
+  .row-fluid .span1 {
+    width: 5.982905982905983%;
+    *width: 5.929714493544281%;
+  }
+  .row-fluid .offset12 {
+    margin-left: 105.12820512820512%;
+    *margin-left: 105.02182214948171%;
+  }
+  .row-fluid .offset12:first-child {
+    margin-left: 102.56410256410257%;
+    *margin-left: 102.45771958537915%;
+  }
+  .row-fluid .offset11 {
+    margin-left: 96.58119658119658%;
+    *margin-left: 96.47481360247316%;
+  }
+  .row-fluid .offset11:first-child {
+    margin-left: 94.01709401709402%;
+    *margin-left: 93.91071103837061%;
+  }
+  .row-fluid .offset10 {
+    margin-left: 88.03418803418803%;
+    *margin-left: 87.92780505546462%;
+  }
+  .row-fluid .offset10:first-child {
+    margin-left: 85.47008547008548%;
+    *margin-left: 85.36370249136206%;
+  }
+  .row-fluid .offset9 {
+    margin-left: 79.48717948717949%;
+    *margin-left: 79.38079650845607%;
+  }
+  .row-fluid .offset9:first-child {
+    margin-left: 76.92307692307693%;
+    *margin-left: 76.81669394435352%;
+  }
+  .row-fluid .offset8 {
+    margin-left: 70.94017094017094%;
+    *margin-left: 70.83378796144753%;
+  }
+  .row-fluid .offset8:first-child {
+    margin-left: 68.37606837606839%;
+    *margin-left: 68.26968539734497%;
+  }
+  .row-fluid .offset7 {
+    margin-left: 62.393162393162385%;
+    *margin-left: 62.28677941443899%;
+  }
+  .row-fluid .offset7:first-child {
+    margin-left: 59.82905982905982%;
+    *margin-left: 59.72267685033642%;
+  }
+  .row-fluid .offset6 {
+    margin-left: 53.84615384615384%;
+    *margin-left: 53.739770867430444%;
+  }
+  .row-fluid .offset6:first-child {
+    margin-left: 51.28205128205128%;
+    *margin-left: 51.175668303327875%;
+  }
+  .row-fluid .offset5 {
+    margin-left: 45.299145299145295%;
+    *margin-left: 45.1927623204219%;
+  }
+  .row-fluid .offset5:first-child {
+    margin-left: 42.73504273504273%;
+    *margin-left: 42.62865975631933%;
+  }
+  .row-fluid .offset4 {
+    margin-left: 36.75213675213675%;
+    *margin-left: 36.645753773413354%;
+  }
+  .row-fluid .offset4:first-child {
+    margin-left: 34.18803418803419%;
+    *margin-left: 34.081651209310785%;
+  }
+  .row-fluid .offset3 {
+    margin-left: 28.205128205128204%;
+    *margin-left: 28.0987452264048%;
+  }
+  .row-fluid .offset3:first-child {
+    margin-left: 25.641025641025642%;
+    *margin-left: 25.53464266230224%;
+  }
+  .row-fluid .offset2 {
+    margin-left: 19.65811965811966%;
+    *margin-left: 19.551736679396257%;
+  }
+  .row-fluid .offset2:first-child {
+    margin-left: 17.094017094017094%;
+    *margin-left: 16.98763411529369%;
+  }
+  .row-fluid .offset1 {
+    margin-left: 11.11111111111111%;
+    *margin-left: 11.004728132387708%;
+  }
+  .row-fluid .offset1:first-child {
+    margin-left: 8.547008547008547%;
+    *margin-left: 8.440625568285142%;
+  }
+  input,
+  textarea,
+  .uneditable-input {
+    margin-left: 0;
+  }
+  .controls-row [class*="span"] + [class*="span"] {
+    margin-left: 30px;
+  }
+  input.span12,
+  textarea.span12,
+  .uneditable-input.span12 {
+    width: 1156px;
+  }
+  input.span11,
+  textarea.span11,
+  .uneditable-input.span11 {
+    width: 1056px;
+  }
+  input.span10,
+  textarea.span10,
+  .uneditable-input.span10 {
+    width: 956px;
+  }
+  input.span9,
+  textarea.span9,
+  .uneditable-input.span9 {
+    width: 856px;
+  }
+  input.span8,
+  textarea.span8,
+  .uneditable-input.span8 {
+    width: 756px;
+  }
+  input.span7,
+  textarea.span7,
+  .uneditable-input.span7 {
+    width: 656px;
+  }
+  input.span6,
+  textarea.span6,
+  .uneditable-input.span6 {
+    width: 556px;
+  }
+  input.span5,
+  textarea.span5,
+  .uneditable-input.span5 {
+    width: 456px;
+  }
+  input.span4,
+  textarea.span4,
+  .uneditable-input.span4 {
+    width: 356px;
+  }
+  input.span3,
+  textarea.span3,
+  .uneditable-input.span3 {
+    width: 256px;
+  }
+  input.span2,
+  textarea.span2,
+  .uneditable-input.span2 {
+    width: 156px;
+  }
+  input.span1,
+  textarea.span1,
+  .uneditable-input.span1 {
+    width: 56px;
+  }
+  .thumbnails {
+    margin-left: -30px;
+  }
+  .thumbnails > li {
+    margin-left: 30px;
+  }
+  .row-fluid .thumbnails {
+    margin-left: 0;
+  }
+}
+@media (max-width: 979px) {
+  body {
+    padding-top: 0;
+  }
+  .navbar-fixed-top,
+  .navbar-fixed-bottom {
+    position: static;
+  }
+  .navbar-fixed-top {
+    margin-bottom: 20px;
+  }
+  .navbar-fixed-bottom {
+    margin-top: 20px;
+  }
+  .navbar-fixed-top .navbar-inner,
+  .navbar-fixed-bottom .navbar-inner {
+    padding: 5px;
+  }
+  .navbar .container {
+    width: auto;
+    padding: 0;
+  }
+  .navbar .brand {
+    padding-left: 10px;
+    padding-right: 10px;
+    margin: 0 0 0 -5px;
+  }
+  .nav-collapse {
+    clear: both;
+  }
+  .nav-collapse .nav {
+    float: none;
+    margin: 0 0 10px;
+  }
+  .nav-collapse .nav > li {
+    float: none;
+  }
+  .nav-collapse .nav > li > a {
+    margin-bottom: 2px;
+  }
+  .nav-collapse .nav > .divider-vertical {
+    display: none;
+  }
+  .nav-collapse .nav .nav-header {
+    color: #777777;
+    text-shadow: none;
+  }
+  .nav-collapse .nav > li > a,
+  .nav-collapse .dropdown-menu a {
+    padding: 9px 15px;
+    font-weight: bold;
+    color: #777777;
+    -webkit-border-radius: 3px;
+    -moz-border-radius: 3px;
+    border-radius: 3px;
+  }
+  .nav-collapse .btn {
+    padding: 4px 10px 4px;
+    font-weight: normal;
+    -webkit-border-radius: 4px;
+    -moz-border-radius: 4px;
+    border-radius: 4px;
+  }
+  .nav-collapse .dropdown-menu li + li a {
+    margin-bottom: 2px;
+  }
+  .nav-collapse .nav > li > a:hover,
+  .nav-collapse .nav > li > a:focus,
+  .nav-collapse .dropdown-menu a:hover,
+  .nav-collapse .dropdown-menu a:focus {
+    background-color: #f2f2f2;
+  }
+  .navbar-inverse .nav-collapse .nav > li > a,
+  .navbar-inverse .nav-collapse .dropdown-menu a {
+    color: #999999;
+  }
+  .navbar-inverse .nav-collapse .nav > li > a:hover,
+  .navbar-inverse .nav-collapse .nav > li > a:focus,
+  .navbar-inverse .nav-collapse .dropdown-menu a:hover,
+  .navbar-inverse .nav-collapse .dropdown-menu a:focus {
+    background-color: #111111;
+  }
+  .nav-collapse.in .btn-group {
+    margin-top: 5px;
+    padding: 0;
+  }
+  .nav-collapse .dropdown-menu {
+    position: static;
+    top: auto;
+    left: auto;
+    float: none;
+    display: none;
+    max-width: none;
+    margin: 0 15px;
+    padding: 0;
+    background-color: transparent;
+    border: none;
+    -webkit-border-radius: 0;
+    -moz-border-radius: 0;
+    border-radius: 0;
+    -webkit-box-shadow: none;
+    -moz-box-shadow: none;
+    box-shadow: none;
+  }
+  .nav-collapse .open > .dropdown-menu {
+    display: block;
+  }
+  .nav-collapse .dropdown-menu:before,
+  .nav-collapse .dropdown-menu:after {
+    display: none;
+  }
+  .nav-collapse .dropdown-menu .divider {
+    display: none;
+  }
+  .nav-collapse .nav > li > .dropdown-menu:before,
+  .nav-collapse .nav > li > .dropdown-menu:after {
+    display: none;
+  }
+  .nav-collapse .navbar-form,
+  .nav-collapse .navbar-search {
+    float: none;
+    padding: 10px 15px;
+    margin: 10px 0;
+    border-top: 1px solid #f2f2f2;
+    border-bottom: 1px solid #f2f2f2;
+    -webkit-box-shadow: inset 0 1px 0 rgba(255,255,255,.1), 0 1px 0 rgba(255,255,255,.1);
+    -moz-box-shadow: inset 0 1px 0 rgba(255,255,255,.1), 0 1px 0 rgba(255,255,255,.1);
+    box-shadow: inset 0 1px 0 rgba(255,255,255,.1), 0 1px 0 rgba(255,255,255,.1);
+  }
+  .navbar-inverse .nav-collapse .navbar-form,
+  .navbar-inverse .nav-collapse .navbar-search {
+    border-top-color: #111111;
+    border-bottom-color: #111111;
+  }
+  .navbar .nav-collapse .nav.pull-right {
+    float: none;
+    margin-left: 0;
+  }
+  .nav-collapse,
+  .nav-collapse.collapse {
+    overflow: hidden;
+    height: 0;
+  }
+  .navbar .btn-navbar {
+    display: block;
+  }
+  .navbar-static .navbar-inner {
+    padding-left: 10px;
+    padding-right: 10px;
+  }
+}
+@media (min-width: 980px) {
+  .nav-collapse.collapse {
+    height: auto !important;
+    overflow: visible !important;
+  }
+}
diff --git a/module/web/static/css/default/admin.less b/module/web/static/css/default/admin.less
new file mode 100644
index 000000000..2ea99da00
--- /dev/null
+++ b/module/web/static/css/default/admin.less
@@ -0,0 +1,27 @@
+@import "common.less";

+

+/* 

+    Admin 

+*/

+

+.popover {

+  width: auto

+}

+

+.name {

+  position: absolute;

+  left: 5px;

+  top: 15px;

+}

+

+#btn_newuser {

+  float: right;

+}

+

+#user_permissions {

+  float: right;

+}

+

+.userperm {

+  width: 115px;

+}
\ No newline at end of file
diff --git a/module/web/static/css/default/common.less b/module/web/static/css/default/common.less
new file mode 100644
index 000000000..a6b9a1e21
--- /dev/null
+++ b/module/web/static/css/default/common.less
@@ -0,0 +1,94 @@
+/*
+   Definitions
+*/
+
+/*
+  Bootstrap size: Phones to tablets, min value when scrollbar appears
+*/
+@min-width: 767px;
+
+/*
+  Threshold for slightly larger screen
+*/
+@large-screen: 1150px;
+
+@header-height: 75px;
+@actionbar-height: 40px;
+@footer-height: 100px;
+
+@light: #ffffff;
+@dark: #333333;
+
+@grey: #757575;
+@greyLight: #E5E5E5;
+@greyLighter: #F5F5F5;
+@greyDark: #444444;
+@greyDarker: #111113;
+
+@yellow: #ffd856;
+@yellowLighter: lighten(spin(@yellow, 10), 20%);
+@yellowLightest: lighten(spin(@yellow, 15), 30%);
+@yellowDark: darken(@yellow, 10%);
+
+@blue: #3571a2;
+@blueLight: lighten(spin(@blue, 5), 10%);
+@blueLighter: lighten(spin(@blue, 10), 20%);
+@blueLightest: lighten(spin(@blue, 20), 40%);
+@blueDark: darken(spin(@blue, -5), 10%);
+@blueDarker: darken(spin(@blue, -10), 20%);
+
+@green: #468847;
+@greenLight: lighten(spin(@green, 5), 10%);
+@greenDark: darken(spin(@green, -5), 10%);
+
+@red: #b94a48;
+@redLight: lighten(spin(@red, 5), 10%);
+@redDark: darken(spin(@red, -5), 10%);
+
+@emph: #FF7637;
+
+
+/*
+  Mixins
+*/
+
+.gradient(@origin: left, @start: #ffffff, @stop: #000000) {
+  background-color: @start;
+  background-image: -webkit-linear-gradient(@origin, @start, @stop);
+  background-image: -moz-linear-gradient(@origin, @start, @stop);
+  background-image: -o-linear-gradient(@origin, @start, @stop);
+  background-image: -ms-linear-gradient(@origin, @start, @stop);
+  background-image: linear-gradient(@origin, @start, @stop);
+}
+
+.transition(@prop: all, @time: 0.25s, @ease: linear) {
+  -webkit-transition: @prop @time @ease;
+  -moz-transition: @prop @time @ease;
+  -o-transition: @prop @time @ease;
+  -ms-transition: @prop @time @ease;
+  transition: @prop @time @ease;
+}
+
+.stripes(@color, @color2: rgba(255, 255, 255, 0.15)) {
+  background-color: @color;
+  background-image: -webkit-linear-gradient(45deg, @color2  25%, transparent 25%, transparent 50%, @color2 50%, @color2 75%, transparent 75%, transparent);
+  background-image: -moz-linear-gradient(45deg, @color2 25%, transparent 25%, transparent 50%, @color2 50%, @color2 75%, transparent 75%, transparent);
+  background-image: -o-linear-gradient(45deg, @color2 25%, transparent 25%, transparent 50%, @color2 50%, @color2 75%, transparent 75%, transparent);
+  background-image: linear-gradient(45deg, @color2 25%, transparent 25%, transparent 50%, @color2 50%, @color2 75%, transparent 75%, transparent);
+  -webkit-background-size: 40px 40px;
+  -moz-background-size: 40px 40px;
+  -o-background-size: 40px 40px;
+  background-size: 40px 40px;
+}
+.stripes-animated {
+  -webkit-animation: progress-bar-stripes 2s linear infinite;
+  -moz-animation: progress-bar-stripes 2s linear infinite;
+  -ms-animation: progress-bar-stripes 2s linear infinite;
+  -o-animation: progress-bar-stripes 2s linear infinite;
+  animation: progress-bar-stripes 2s linear infinite;
+}
+
+
+.default-shadow {
+  box-shadow: 0 0 5px @dark;
+}
\ No newline at end of file
diff --git a/module/web/static/css/default/dashboard.less b/module/web/static/css/default/dashboard.less
new file mode 100644
index 000000000..cf6e0d410
--- /dev/null
+++ b/module/web/static/css/default/dashboard.less
@@ -0,0 +1,327 @@
+@import "common.less";

+

+/*

+    Dashboard

+*/

+

+#dashboard ul {

+  margin: 0;

+  list-style: none;

+}

+

+.sidebar-header {

+  font-size: 25px;

+  line-height: 25px;

+  margin: 4px 0;

+  border-bottom: 1px dashed @grey;

+}

+

+/*

+  Packages

+*/

+

+.package-list {

+  list-style: none;

+  margin-left: 0;

+}

+

+@frame-top: 20px;

+@frame-bottom: 18px;

+

+.package-frame {

+  position: absolute;

+  top: -@frame-top;

+  left: -@frame-top / 2;

+  right: -@frame-top / 2;

+  bottom: -@frame-bottom + 2px; // + size of visible bar

+  z-index: -1; // lies under package

+  border: 1px solid @grey;

+  border-radius: 5px;

+  box-shadow: 3px 3px 6px rgba(0, 0, 0, 0.75);

+}

+

+.package-view {

+  padding-bottom: 4px;

+  margin: 8px 0;

+  position: relative;

+  overflow: hidden;

+

+  -webkit-hyphens: auto;

+  -moz-hyphens: auto;

+  hyphens: auto;

+

+  i {

+    cursor: pointer;

+  }

+

+  .progress {

+    position: absolute;

+    height: @frame-bottom;

+    line-height: @frame-bottom;

+    font-size: 12px;

+    text-align: center;

+    border-radius: 0;

+    border-bottom-left-radius: 5px;

+    border-bottom-right-radius: 5px;

+    bottom: 0;

+    left: 0;

+    right: 0;

+    margin-bottom: 0;

+    background-image: none;

+    color: @light;

+    background-color: @yellow;

+  }

+

+  .bar-info {

+    background-image: none;

+    background-color: @blue;

+  }

+

+  &:hover {

+    overflow: visible;

+    z-index: 10;

+

+    .package-frame {

+      background-color: @light;

+    }

+  }

+

+  &.ui-selected:hover {

+    color: @light;

+

+    .package-frame {

+      background-color: @dark;

+    }

+

+  }

+}

+

+.package-name {

+  cursor: pointer;

+}

+

+.package-indicator {

+  position: absolute;

+  top: 0;

+  right: 0;

+  float: right;

+  color: @blue;

+  text-shadow: @yellowDark 1px 1px;

+  height: @frame-top;

+  line-height: @frame-top;

+

+  & > i:hover {

+    color: @green;

+  }

+

+  .dropdown-menu {

+    text-shadow: none;

+  }

+

+  .tooltip {

+    text-shadow: none;

+    width: 100%;

+  }

+

+  .btn-move {

+    color: @green;

+    display: none;

+  }

+

+}

+

+.ui-files-selected .btn-move {

+  display: inline;

+}

+

+// Tag area with different effect on hover

+.tag-area {

+  position: absolute;

+  top: -2px;

+  left: 0;

+

+  .badge {

+    font-size: 11px;

+    line-height: 11px;

+  }

+

+  .badge i {

+    cursor: pointer;

+    &:hover:before {

+      content: "\f024"; // show Remove icon

+    }

+  }

+

+  .badge-ghost {

+    visibility: hidden;

+    cursor: pointer;

+    opacity: 0.5;

+  }

+

+  &:hover .badge-ghost {

+    visibility: visible;

+  }

+

+}

+

+/*

+  File View

+*/

+

+.file-list {

+  list-style: none;

+  margin: 0;

+}

+

+@file-height: 22px;

+

+.file-view {

+  position: relative;

+  padding: 0 4px;

+  border-top: 1px solid #dddddd;

+  line-height: @file-height;

+

+  &:first-child {

+    border-top: none;

+  }

+

+  &:hover, &.ui-selected:hover {

+    border-radius: 5px;

+    .gradient(top, @blue, @blueLight);

+    color: @light;

+  }

+

+  &.ui-selected {

+    .gradient(top, @yellow, @yellowDark);

+    color: @dark;

+    border-color: @greenDark;

+

+    .file-row.downloading .bar {

+        .gradient(top, @green, @greenLight);

+    }

+

+  }

+

+  img { // plugin logo

+    margin-top: -2px;

+    padding: 0 2px;

+    height: @file-height;

+    width: @file-height;

+  }

+

+  .iconf-chevron-down:hover {

+    cursor: pointer;

+    color: @yellow;

+  }

+

+}

+

+.file-row {

+  min-height: 0 !important;

+//  padding-left: 5px;

+  padding-top: 4px;

+  padding-bottom: 4px;

+

+  // TODO: better styling for filestatus

+  &.second {

+//    border-radius: 4px;

+//    background: @light;

+    font-size: small;

+    font-weight: bold;

+//    box-shadow: 3px 3px 6px rgba(0, 0, 0, 0.75);

+//    .default-shadow;

+  }

+

+  &.third {

+    margin-left: 0;

+    position: relative;

+    font-size: small;

+  }

+

+  .dropdown-menu {

+    font-size: medium;

+  }

+}

+

+/*

+ TODO: more colorful states

+ better fileView design

+*/

+

+.file-row.finished {

+//  .gradient(top, @green, @greenLight);

+//  color: @light;

+  color: @green;

+}

+

+.file-row.failed {

+//  .gradient(top, @red, @redLight);

+//  color: @light;

+  color: @red;

+}

+

+.file-row.downloading  {

+

+  .progress {

+    height: @file-height;

+    background: @light;

+    margin: 0;

+  }

+

+  .bar {

+    text-align: left;

+    .gradient(top, @yellow, @yellowDark);

+    color: @dark;

+  }

+

+}

+

+/*

+FANCY CHECKBOXES

+*/

+.file-view .checkbox {

+  width: 20px;

+  height: 21px;

+  background: url(../../img/default/checks_sheet.png) left top no-repeat;

+  cursor: pointer;

+}

+

+.file-view.ui-selected .checkbox {

+  background: url(../../img/default/checks_sheet.png) -21px top no-repeat;

+}

+

+/*

+  Actionbar

+*/

+

+.form-search {

+  position: relative;

+

+  .dropdown-menu {

+    min-width: 100%;

+    position: absolute;

+    right: 0;

+    left: auto;

+  }

+

+}

+

+li.finished > a, li.finished:hover > a {

+  background-color: @green;

+  color: @light;

+

+  .caret, .caret:hover {

+    border-bottom-color: @light !important;

+    border-top-color: @light !important;

+  }

+}

+

+li.failed > a, li.failed:hover > a {

+  background-color: @red;

+  color: @light;

+

+  .caret, .caret:hover {

+    border-bottom-color: @light !important;

+    border-top-color: @light !important;

+  }

+}
\ No newline at end of file
diff --git a/module/web/static/css/default/settings.less b/module/web/static/css/default/settings.less
new file mode 100644
index 000000000..4b4efb423
--- /dev/null
+++ b/module/web/static/css/default/settings.less
@@ -0,0 +1,51 @@
+@import "common.less";

+

+/* 

+    Settings 

+*/

+.settings-menu {

+  background-color: #FFF;

+  box-shadow: 0 0 5px #000;

+//  border: 10px solid #EEE;

+

+

+  .nav-header {

+    background: @blueDark;

+    color: @light;

+  }

+

+   li > a, .nav-header {

+    margin-left: -20px;

+    margin-right: -20px;

+    text-shadow: none;

+  }

+

+  i {

+    margin-top: 0;

+  }

+

+  border-top-left-radius: 0;

+  border-top-right-radius: 0;

+

+}

+

+.nav > li > a:hover {

+  color: @blueDark;

+}

+

+.setting-box {

+  border: 10px solid @blueDark;

+  box-shadow: 0 0 5px @dark;

+//  .gradient(bottom, @yellowLightest, @light);

+

+  .page-header {

+    margin: 0;

+

+    .btn {

+      float: right;

+      margin-top: 5px;

+    }

+

+  }

+

+}
\ No newline at end of file
diff --git a/module/web/static/css/default/style.less b/module/web/static/css/default/style.less
new file mode 100644
index 000000000..120864f39
--- /dev/null
+++ b/module/web/static/css/default/style.less
@@ -0,0 +1,545 @@
+@import "common.less";

+

+/*

+   General

+*/

+

+* {

+  margin: 0;

+}

+

+html, body {

+  height: 100%;

+}

+

+body {

+  margin: 0;

+  padding: 0;

+  font-family: 'Abel', sans-serif;

+  font-size: 16px;

+  background: url("../../img/default/bgpattern.png") repeat scroll 0 0 transparent;

+  min-width: @min-width;

+}

+

+h1, h2, h3 {

+  margin: 0;

+  padding: 0;

+  font-weight: normal;

+}

+

+a {

+  text-decoration: none;

+  color: @blue;

+}

+

+a:hover {

+  text-decoration: none;

+  color: @emph;

+}

+

+#wrap {

+  min-height: 100%;

+}

+

+#content {

+  padding-bottom: @footer-height;

+}

+

+#content-container:before {

+  display: block;

+  content: " ";

+  height: @header-height;

+}

+

+/*

+  Additional Responsive Class for larger desktop

+*/

+

+.visible-large-screen {

+  display: inherit !important;

+}

+

+@media (max-width: @large-screen) {

+  .visible-large-screen {

+    display: none !important;

+  }

+}

+

+.btn-blue {

+  background-color: hsl(206, 49%, 35%) !important;

+  background-repeat: repeat-x;

+  background-image: -khtml-gradient(linear, left top, left bottom, from(#5493c4), to(#2d5f84));

+  background-image: -moz-linear-gradient(top, #5493c4, #2d5f84);

+  background-image: -ms-linear-gradient(top, #5493c4, #2d5f84);

+  background-image: -webkit-gradient(linear, left top, left bottom, color-stop(0%, #5493c4), color-stop(100%, #2d5f84));

+  background-image: -webkit-linear-gradient(top, #5493c4, #2d5f84);

+  background-image: -o-linear-gradient(top, #5493c4, #2d5f84);

+  background-image: linear-gradient(#5493c4, #2d5f84);

+  border-color: #2d5f84 #2d5f84 hsl(206, 49%, 30%);

+  color: #fff !important;

+  text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.33);

+  -webkit-font-smoothing: antialiased;

+

+  .caret {

+    border-bottom-color: #FFFFFF;

+    border-top-color: #FFFFFF;

+  }

+

+}

+

+.btn-yellow {

+  background-color: hsl(46, 100%, 57%) !important;

+  background-repeat: repeat-x;

+  background-image: -khtml-gradient(linear, left top, left bottom, from(#ffe389), to(#fecb23));

+  background-image: -moz-linear-gradient(top, #ffe389, #fecb23);

+  background-image: -ms-linear-gradient(top, #ffe389, #fecb23);

+  background-image: -webkit-gradient(linear, left top, left bottom, color-stop(0%, #ffe389), color-stop(100%, #fecb23));

+  background-image: -webkit-linear-gradient(top, #ffe389, #fecb23);

+  background-image: -o-linear-gradient(top, #ffe389, #fecb23);

+  background-image: linear-gradient(#ffe389, #fecb23);

+  border-color: #fecb23 #fecb23 hsl(46, 100%, 52%);

+  color: #333 !important;

+  text-shadow: 0 1px 1px rgba(255, 255, 255, 0.33);

+  -webkit-font-smoothing: antialiased;

+

+  .caret {

+    border-bottom-color: #FFFFFF;

+    border-top-color: #FFFFFF;

+  }

+}

+

+.iconf-8x {

+  font-size: 8em;

+}

+

+// Will not work well in buttons/navs, would require more rules

+.iconf-larger {

+  vertical-align: -10%;

+  font-size: 1.5em;

+}

+

+/*

+    Header

+*/

+

+header { //  background-color: @greyDark;

+  background: url("../../img/default/bgpatterndark.png") repeat;

+  height: @header-height;

+  position: fixed;

+  top: 0;

+  vertical-align: top;

+  width: 100%;

+  z-index: 10;

+  min-width: @min-width;

+  color: #ffffff;

+}

+

+header a {

+  color: #ffffff;

+}

+

+header:before {

+  position: absolute;

+  content: ' ';

+  top: 0;

+  right: 0;

+  bottom: 0;

+  left: 0;

+  background-color: transparent;

+  z-index: -1;

+  .default-shadow;

+}

+

+header div.left {

+  position: relative;

+  padding-left: 20px;

+  height: @header-height;

+  float: left; //  border-right: 1px solid;

+}

+

+header div.right {

+  padding-right: 20px;

+}

+

+header span.title {

+  color: white;

+  float: left;

+  font-family: SansationRegular, sans-serif;

+  font-size: 40px;

+  line-height: @header-height;

+  cursor: default;

+}

+

+header .logo {

+  float: left;

+  margin-right: 10px;

+  margin-top: 12px;

+  width: 105px;

+  height: 107px;

+  background: url("../../img/default/logo.png") no-repeat;

+}

+

+.header_block {

+  float: right; //  font-family: SansationRegular, sans-serif;

+  margin: 10px 8px 0;

+  line-height: 18px;

+  font-size: small;

+

+  .btn {

+    margin-top: 6px;

+  }

+

+}

+

+.iconbar {

+  display: inline-block;

+  width: 100%;

+  text-align: center;

+  text-shadow: @blue 2px 2px 2px;

+

+  i {

+    cursor: pointer;

+  }

+

+  i:hover {

+    color: @yellow;

+  }

+

+}

+

+// Responsive Borders

+.header_block.left-border {

+  background: url("../../img/default/box-separator.png") repeat-y;

+  padding-left: 1%;

+}

+

+.header_block.right-border {

+  background: url("../../img/default/box-separator.png") repeat-y right;

+  padding-right: 1%;

+

+  .pull-right {

+    color: @yellow;

+  }

+

+}

+

+@media (max-width: @large-screen) {

+  .header_block {

+    background: none !important;

+    padding: 0 !important;

+  }

+}

+

+#progress-area {

+  position: relative;

+  float: right;

+  width: 26%;

+  margin-top: 12px;

+  margin-right: 15px;

+  line-height: 16px;

+

+  #progress-info {

+    padding-left: 2px;

+  }

+

+  .sub {

+    font-size: small;

+    padding: 0 2px;

+  }

+

+  .popover { //    display: block;

+    max-width: none;

+    width: 120%;

+    left: -60%; // Half of width

+    margin-left: 50%;

+    top: 100%;

+  }

+

+  .popover-title, .popover-content {

+    color: @greyDark;

+  }

+

+  .iconf-list {

+    cursor: pointer;

+    margin-right: 2px; // same as globalprogress margin

+

+    &:hover {

+      color: @yellow;

+    }

+  }

+  .close {

+    line-height: 14px;

+  }

+}

+

+.progress-list {

+  list-style: none;

+  margin: 0;

+  font-size: small;

+

+  li {

+    background-repeat: no-repeat;

+    background-size: 32px 32px;

+    background-position: 0px 8px;

+    padding-left: 40px;

+

+    &:not(:last-child) {

+      margin-bottom: 5px;

+      padding-bottom: 5px;

+      border-bottom: 1px dashed @greyLight;

+    }

+

+    .progress {

+      height: 8px;

+      margin-bottom: 0;

+

+      .bar {

+        .gradient(bottom, @blue, @blueLight);

+      }

+    }

+  }

+}

+

+#globalprogress {

+  background-color: @greyDark;

+  background-image: none;

+  height: 8px;

+  margin: 4px 0;

+  border-radius: 8px;

+  border: 2px solid @grey;

+

+  .bar {

+    color: @dark;

+    background-image: none;

+    background-color: @yellow;

+

+    &.running {

+      width: 100%;

+      .stripes(@yellowLighter, @yellowDark);

+    }

+

+  }

+

+}

+

+#speedgraph {

+  float: right;

+  width: 14%;

+  height: 60px; // similiar as header_box

+  margin: 8px 8px 0 8px;

+  font-family: sans-serif

+}

+

+.header-area {

+  display: none; // hidden by default

+  position: absolute;

+  bottom: -28px;

+  line-height: 18px;

+  top: @header-height;

+  padding: 4px 10px 6px 10px;

+  text-align: center;

+  border-radius: 0 0 6px 6px;

+  color: @light;

+  background-color: @greyDark;

+  .default-shadow;

+}

+

+#notification-area {

+  .header-area;

+  left: 140px;

+

+  .badge {

+    vertical-align: top;

+  }

+

+  .btn-query, .btn-notification {

+    cursor: pointer;

+  }

+}

+

+#selection-area {

+  .header-area;

+  left: 50%;

+  min-width: 15%;

+

+  i {

+    cursor: pointer;

+

+    &:hover {

+      color: @yellow;

+    }

+  }

+

+}

+

+/*

+   Actionbar

+*/

+

+.nav > li > a:hover {

+  color: @blue;

+}

+

+.actionbar {

+  padding-bottom: 3px;

+  margin-bottom: 0;

+  border-bottom: 1px dashed @grey;

+

+  height: @actionbar-height;

+

+  padding-top: 2px;

+  margin-bottom: 5px;

+

+}

+

+.actionbar > li > a {

+  margin-top: 4px;

+}

+

+.actionbar .breadcrumb {

+  margin: 0;

+  padding-top: 10px;

+  padding-bottom: 0;

+

+  .active {

+    color: @grey;

+  }

+

+}

+

+.actionbar form {

+  margin-top: 8px;

+  margin-bottom: 0;

+}

+

+.actionbar input, .actionbar button {

+  padding-top: 2px;

+  padding-bottom: 2px;

+}

+

+.actionbar .dropdown-menu i {

+  margin-top: 4px;

+  padding-right: 5px;

+}

+

+/*

+    Login

+*/

+.login {

+  vertical-align: middle;

+  border: 2px solid @dark;

+  padding: 15px 50px;

+  font-size: 17px;

+  border-radius: 15px;

+  -moz-border-radius: 15px;

+  -webkit-border-radius: 15px;

+}

+

+/*

+    Footer

+*/

+footer { //  background-color: @greyDark;

+  background: url("../../img/default/bgpatterndark.png") repeat;

+  color: @grey;

+  height: @footer-height;

+  margin-top: -@footer-height;

+  position: relative;

+  width: 100%;

+  line-height: 16px;

+  z-index: 10;

+}

+

+footer .logo {

+  background: url(../../img/default/logo_grey.png) no-repeat;

+  float: left;

+  width: 60px;

+  height: 60px;

+  margin-top: 12px;

+  margin-right: 12px;

+}

+

+footer div.center {

+  padding-top: 8px;

+  width: 900px;

+  margin-left: auto;

+  margin-right: auto;

+}

+

+footer:before {

+  position: absolute;

+  content: ' ';

+  top: 0;

+  right: 0;

+  bottom: 0;

+  left: 0;

+  background-color: transparent;

+  box-shadow: 0 0 5px black;

+  z-index: -1;

+}

+

+footer .block {

+  font-size: 12px;

+  float: left;

+  margin: 0;

+  width: 150px;

+  padding-top: 6px;

+  padding-right: 30px;

+}

+

+footer .copyright {

+  text-align: center;

+  width: auto;

+  padding-top: 22px;

+}

+

+footer h2 {

+  background: url("../../img/default/double-line.gif") repeat-x scroll center bottom transparent !important;

+  color: #FFFFFF;

+  font-family: SansationLight, sans-serif;

+  font-size: 16px;

+  font-weight: normal;

+  line-height: 16px;

+  margin: 0;

+  padding-bottom: 6px;

+}

+

+/*

+   Modal Overlay

+*/

+#modal-overlay {

+  content: " ";

+  height: 100%;

+  width: 100%;

+  position: absolute;

+  left: 0;

+  top: 0;

+  background: -moz-radial-gradient(center, ellipse cover, rgba(236, 208, 66, 0) 0%, rgba(40, 119, 171, 0.9) 100%);

+  background: -webkit-gradient(radial, center center, 0px, center center, 100%, color-stop(0%, rgba(236, 208, 66, 0)), color-stop(100%, rgba(40, 119, 171, 0.9)));

+  background: -webkit-radial-gradient(center, ellipse cover, rgba(236, 208, 66, 0) 0%, rgba(40, 119, 171, 0.9) 100%);

+  background: -o-radial-gradient(center, ellipse cover, rgba(236, 208, 66, 0) 0%, rgba(40, 119, 171, 0.9) 100%);

+  background: -ms-radial-gradient(center, ellipse cover, rgba(236, 208, 66, 0) 0%, rgba(40, 119, 171, 0.9) 100%);

+  background: radial-gradient(center, ellipse cover, rgba(236, 208, 66, 0) 0%, rgba(40, 119, 171, 0.9) 100%);

+  z-index: 100;

+  opacity: 0;

+}

+

+div.modal-header {

+  border-top-left-radius: 4px;

+  border-top-right-radius: 4px;

+  background-color: @blueDark;

+  color: #FFFFFF;

+

+  .close {

+    color: @light;

+  }

+

+}

+

+div.modal-body {

+  max-height: 100%;

+}

+

+div.modal {

+  width: 600px;

+

+}

diff --git a/module/web/static/css/font.css b/module/web/static/css/font.css
new file mode 100644
index 000000000..ee117d43b
--- /dev/null
+++ b/module/web/static/css/font.css
@@ -0,0 +1,37 @@
+/**
+ * @file
+ * Font styling
+ */
+
+@font-face {
+    font-family: 'SansationRegular';
+    src: url('../fonts/Sansation_Regular-webfont.eot');
+    src: url('../fonts/Sansation_Regular-webfont.eot?#iefix') format('embedded-opentype'),
+         url('../fonts/Sansation_Regular-webfont.woff') format('woff'),
+         url('../fonts/Sansation_Regular-webfont.ttf') format('truetype'),
+         url('../fonts/Sansation_Regular-webfont.svg#SansationRegular') format('svg');
+    font-weight: normal;
+    font-style: normal;
+}
+
+@font-face {
+    font-family: 'SansationLight';
+    src: url('../fonts/Sansation_Light-webfont.eot');
+    src: url('../fonts/Sansation_Light-webfont.eot?#iefix') format('embedded-opentype'),
+         url('../fonts/Sansation_Light-webfont.woff') format('woff'),
+         url('../fonts/Sansation_Light-webfont.ttf') format('truetype'),
+         url('../fonts/Sansation_Light-webfont.svg#SansationLight') format('svg');
+    font-weight: normal;
+    font-style: normal;
+}
+
+@font-face {
+    font-family: 'SansationBold';
+    src: url('../fonts/Sansation_Bold-webfont.eot');
+    src: url('../fonts/Sansation_Bold-webfont.eot?#iefix') format('embedded-opentype'),
+         url('../fonts/Sansation_Bold-webfont.woff') format('woff'),
+         url('../fonts/Sansation_Bold-webfont.ttf') format('truetype'),
+         url('../fonts/Sansation_Bold-webfont.svg#SansationBold') format('svg');
+    font-weight: normal;
+    font-style: normal;
+}
\ No newline at end of file
diff --git a/module/web/static/css/fontawesome.css b/module/web/static/css/fontawesome.css
new file mode 100644
index 000000000..0e6dbfa09
--- /dev/null
+++ b/module/web/static/css/fontawesome.css
@@ -0,0 +1,334 @@
+/*!
+ *  Font Awesome 3.0.2
+ *  the iconic font designed for use with Twitter Bootstrap
+ *  -------------------------------------------------------
+ *  The full suite of pictographic icons, examples, and documentation
+ *  can be found at: http://fortawesome.github.com/Font-Awesome/
+ *
+ *  License
+ *  -------------------------------------------------------
+ *  - The Font Awesome font is licensed under the SIL Open Font License - http://scripts.sil.org/OFL
+ *  - Font Awesome CSS, LESS, and SASS files are licensed under the MIT License -
+ *    http://opensource.org/licenses/mit-license.html
+ *  - The Font Awesome pictograms are licensed under the CC BY 3.0 License - http://creativecommons.org/licenses/by/3.0/
+ *  - Attribution is no longer required in Font Awesome 3.0, but much appreciated:
+ *    "Font Awesome by Dave Gandy - http://fortawesome.github.com/Font-Awesome"
+
+ *  Contact
+ *  -------------------------------------------------------
+ *  Email: dave@davegandy.com
+ *  Twitter: http://twitter.com/fortaweso_me
+ *  Work: Lead Product Designer @ http://kyruus.com
+ */
+@font-face {
+  font-family: 'FontAwesome';
+  src: url('../fonts/fontawesome-webfont.eot?v=3.0.1');
+  src: url('../fonts/fontawesome-webfont.eot?#iefix&v=3.0.1') format('embedded-opentype'),
+    url('../fonts/fontawesome-webfont.woff?v=3.0.1') format('woff'),
+    url('../fonts/fontawesome-webfont.ttf?v=3.0.1') format('truetype');
+  font-weight: normal;
+  font-style: normal;
+}
+/*  Font Awesome styles
+    ------------------------------------------------------- */
+[class^="iconf-"],
+[class*=" iconf-"] {
+  font-family: FontAwesome;
+  font-weight: normal;
+  font-style: normal;
+  text-decoration: inherit;
+  -webkit-font-smoothing: antialiased;
+
+  /* sprites.less reset */
+  display: inline;
+  width: auto;
+  height: auto;
+  line-height: normal;
+  vertical-align: baseline;
+  background-image: none;
+  background-position: 0% 0%;
+  background-repeat: repeat;
+  margin-top: 0;
+}
+/* more sprites.less reset */
+.iconf-white,
+.nav-pills > .active > a > [class^="iconf-"],
+.nav-pills > .active > a > [class*=" iconf-"],
+.nav-list > .active > a > [class^="iconf-"],
+.nav-list > .active > a > [class*=" iconf-"],
+.navbar-inverse .nav > .active > a > [class^="iconf-"],
+.navbar-inverse .nav > .active > a > [class*=" iconf-"],
+.dropdown-menu > li > a:hover > [class^="iconf-"],
+.dropdown-menu > li > a:hover > [class*=" iconf-"],
+.dropdown-menu > .active > a > [class^="iconf-"],
+.dropdown-menu > .active > a > [class*=" iconf-"],
+.dropdown-submenu:hover > a > [class^="iconf-"],
+.dropdown-submenu:hover > a > [class*=" iconf-"] {
+  background-image: none;
+}
+[class^="iconf-"]:before,
+[class*=" iconf-"]:before {
+  text-decoration: inherit;
+  display: inline-block;
+  speak: none;
+}
+/* makes sure icons active on rollover in links */
+a [class^="iconf-"],
+a [class*=" iconf-"] {
+  display: inline-block;
+}
+/* makes the font 33% larger relative to the icon container */
+.iconf-large:before {
+  vertical-align: -10%;
+  font-size: 1.3333333333333333em;
+}
+.btn [class^="iconf-"],
+.nav [class^="iconf-"],
+.btn [class*=" iconf-"],
+.nav [class*=" iconf-"] {
+  display: inline;
+  /* keeps button heights with and without icons the same */
+
+}
+.btn [class^="iconf-"].iconf-large,
+.nav [class^="iconf-"].iconf-large,
+.btn [class*=" iconf-"].iconf-large,
+.nav [class*=" iconf-"].iconf-large {
+  line-height: .9em;
+}
+.btn [class^="iconf-"].iconf-spin,
+.nav [class^="iconf-"].iconf-spin,
+.btn [class*=" iconf-"].iconf-spin,
+.nav [class*=" iconf-"].iconf-spin {
+  display: inline-block;
+}
+.nav-tabs [class^="iconf-"],
+.nav-pills [class^="iconf-"],
+.nav-tabs [class*=" iconf-"],
+.nav-pills [class*=" iconf-"] {
+  /* keeps button heights with and without icons the same */
+
+}
+.nav-tabs [class^="iconf-"],
+.nav-pills [class^="iconf-"],
+.nav-tabs [class*=" iconf-"],
+.nav-pills [class*=" iconf-"],
+.nav-tabs [class^="iconf-"].iconf-large,
+.nav-pills [class^="iconf-"].iconf-large,
+.nav-tabs [class*=" iconf-"].iconf-large,
+.nav-pills [class*=" iconf-"].iconf-large {
+  line-height: .9em;
+}
+li [class^="iconf-"],
+.nav li [class^="iconf-"],
+li [class*=" iconf-"],
+.nav li [class*=" iconf-"] {
+  display: inline-block;
+  width: 1.25em;
+  text-align: center;
+}
+li [class^="iconf-"].iconf-large,
+.nav li [class^="iconf-"].iconf-large,
+li [class*=" iconf-"].iconf-large,
+.nav li [class*=" iconf-"].iconf-large {
+  /* increased font size for iconf-large */
+
+  width: 1.5625em;
+}
+ul.icons {
+  list-style-type: none;
+  text-indent: -0.75em;
+}
+ul.icons li [class^="iconf-"],
+ul.icons li [class*=" iconf-"] {
+  width: .75em;
+}
+.iconf-muted {
+  color: #eeeeee;
+}
+.iconf-border {
+  border: solid 1px #eeeeee;
+  padding: .2em .25em .15em;
+  -webkit-border-radius: 3px;
+  -moz-border-radius: 3px;
+  border-radius: 3px;
+}
+.iconf-2x {
+  font-size: 2em;
+}
+.iconf-2x.iconf-border {
+  border-width: 2px;
+  -webkit-border-radius: 4px;
+  -moz-border-radius: 4px;
+  border-radius: 4px;
+}
+.iconf-3x {
+  font-size: 3em;
+}
+.iconf-3x.iconf-border {
+  border-width: 3px;
+  -webkit-border-radius: 5px;
+  -moz-border-radius: 5px;
+  border-radius: 5px;
+}
+.iconf-4x {
+  font-size: 4em;
+}
+.iconf-4x.iconf-border {
+  border-width: 4px;
+  -webkit-border-radius: 6px;
+  -moz-border-radius: 6px;
+  border-radius: 6px;
+}
+.pull-right {
+  float: right;
+}
+.pull-left {
+  float: left;
+}
+[class^="iconf-"].pull-left,
+[class*=" iconf-"].pull-left {
+  margin-right: .3em;
+}
+[class^="iconf-"].pull-right,
+[class*=" iconf-"].pull-right {
+  margin-left: .3em;
+}
+.btn [class^="iconf-"].pull-left.iconf-2x,
+.btn [class*=" iconf-"].pull-left.iconf-2x,
+.btn [class^="iconf-"].pull-right.iconf-2x,
+.btn [class*=" iconf-"].pull-right.iconf-2x {
+  margin-top: .18em;
+}
+.btn [class^="iconf-"].iconf-spin.iconf-large,
+.btn [class*=" iconf-"].iconf-spin.iconf-large {
+  line-height: .8em;
+}
+.btn.btn-small [class^="iconf-"].pull-left.iconf-2x,
+.btn.btn-small [class*=" iconf-"].pull-left.iconf-2x,
+.btn.btn-small [class^="iconf-"].pull-right.iconf-2x,
+.btn.btn-small [class*=" iconf-"].pull-right.iconf-2x {
+  margin-top: .25em;
+}
+.btn.btn-large [class^="iconf-"],
+.btn.btn-large [class*=" iconf-"] {
+  margin-top: 0;
+}
+.btn.btn-large [class^="iconf-"].pull-left.iconf-2x,
+.btn.btn-large [class*=" iconf-"].pull-left.iconf-2x,
+.btn.btn-large [class^="iconf-"].pull-right.iconf-2x,
+.btn.btn-large [class*=" iconf-"].pull-right.iconf-2x {
+  margin-top: .05em;
+}
+.btn.btn-large [class^="iconf-"].pull-left.iconf-2x,
+.btn.btn-large [class*=" iconf-"].pull-left.iconf-2x {
+  margin-right: .2em;
+}
+.btn.btn-large [class^="iconf-"].pull-right.iconf-2x,
+.btn.btn-large [class*=" iconf-"].pull-right.iconf-2x {
+  margin-left: .2em;
+}
+.iconf-spin {
+  display: inline-block;
+  -moz-animation: spin 2s infinite linear;
+  -o-animation: spin 2s infinite linear;
+  -webkit-animation: spin 2s infinite linear;
+  animation: spin 2s infinite linear;
+}
+@-moz-keyframes spin {
+  0% { -moz-transform: rotate(0deg); }
+  100% { -moz-transform: rotate(359deg); }
+}
+@-webkit-keyframes spin {
+  0% { -webkit-transform: rotate(0deg); }
+  100% { -webkit-transform: rotate(359deg); }
+}
+@-o-keyframes spin {
+  0% { -o-transform: rotate(0deg); }
+  100% { -o-transform: rotate(359deg); }
+}
+@-ms-keyframes spin {
+  0% { -ms-transform: rotate(0deg); }
+  100% { -ms-transform: rotate(359deg); }
+}
+@keyframes spin {
+  0% { transform: rotate(0deg); }
+  100% { transform: rotate(359deg); }
+}
+@-moz-document url-prefix() {
+  .iconf-spin {
+    height: .9em;
+  }
+  .btn .iconf-spin {
+    height: auto;
+  }
+  .iconf-spin.iconf-large {
+    height: 1.25em;
+  }
+  .btn .iconf-spin.iconf-large {
+    height: .75em;
+  }
+}.iconf-music:before		{ content: "\f021"; }
+.iconf-search:before		{ content: "\f022"; }
+.iconf-user:before		{ content: "\f023"; }
+.iconf-film:before		{ content: "\f024"; }
+.iconf-file:before		{ content: "\f025"; }
+.iconf-download-alt:before		{ content: "\f026"; }
+.iconf-download:before		{ content: "\f027"; }
+.iconf-inbox:before		{ content: "\f028"; }
+.iconf-ok:before		{ content: "\f029"; }
+.iconf-remove:before		{ content: "\f02a"; }
+.iconf-cog:before		{ content: "\f02b"; }
+.iconf-trash:before		{ content: "\f02c"; }
+.iconf-time:before		{ content: "\f02d"; }
+.iconf-repeat:before		{ content: "\f02e"; }
+.iconf-refresh:before		{ content: "\f02f"; }
+.iconf-list-alt:before		{ content: "\f030"; }
+.iconf-lock:before		{ content: "\f031"; }
+.iconf-tag:before		{ content: "\f032"; }
+.iconf-tags:before		{ content: "\f033"; }
+.iconf-print:before		{ content: "\f034"; }
+.iconf-list:before		{ content: "\f035"; }
+.iconf-picture:before		{ content: "\f036"; }
+.iconf-pencil:before		{ content: "\f037"; }
+.iconf-edit:before		{ content: "\f038"; }
+.iconf-share:before		{ content: "\f039"; }
+.iconf-check:before		{ content: "\f03a"; }
+.iconf-play:before		{ content: "\f03b"; }
+.iconf-pause:before		{ content: "\f03c"; }
+.iconf-stop:before		{ content: "\f03d"; }
+.iconf-share-alt:before		{ content: "\f03e"; }
+.iconf-eye-open:before		{ content: "\f03f"; }
+.iconf-eye-close:before		{ content: "\f040"; }
+.iconf-bar-chart:before		{ content: "\f041"; }
+.iconf-check-empty:before		{ content: "\f042"; }
+.iconf-globe:before		{ content: "\f043"; }
+.iconf-tasks:before		{ content: "\f044"; }
+.iconf-filter:before		{ content: "\f045"; }
+.iconf-plus-sign:before		{ content: "\f046"; }
+.iconf-chevron-left:before		{ content: "\f047"; }
+.iconf-chevron-right:before		{ content: "\f048"; }
+.iconf-chevron-up:before		{ content: "\f049"; }
+.iconf-chevron-down:before		{ content: "\f04a"; }
+.iconf-key:before		{ content: "\f04b"; }
+.iconf-cogs:before		{ content: "\f04c"; }
+.iconf-signout:before		{ content: "\f04d"; }
+.iconf-signin:before		{ content: "\f04e"; }
+.iconf-hdd:before		{ content: "\f04f"; }
+.iconf-hand-left:before		{ content: "\f050"; }
+.iconf-hand-down:before		{ content: "\f051"; }
+.iconf-wrench:before		{ content: "\f052"; }
+.iconf-inbox:before		{ content: "\f053"; }
+.iconf-share:before		{ content: "\f054"; }
+.iconf-group:before		{ content: "\f055"; }
+.iconf-cloud:before		{ content: "\f056"; }
+.iconf-save:before		{ content: "\f057"; }
+.iconf-carret-left:before		{ content: "\f058"; }
+.iconf-sort-down:before		{ content: "\f059"; }
+.iconf-sort-up:before		{ content: "\f05a"; }
+.iconf-sitemap:before		{ content: "\f05b"; }
+.iconf-file-alt:before		{ content: "\f05c"; }
+.iconf-folder-open:before		{ content: "\f05d"; }
+.iconf-folder-open-alt:before		{ content: "\f05e"; }
+.iconf-folder-close:before		{ content: "\f05f"; }
+.iconf-folder-close-alt:before		{ content: "\f060"; }
diff --git a/module/web/static/css/mobile/images/ajax-loader.gif b/module/web/static/css/mobile/images/ajax-loader.gif
new file mode 100644
index 000000000..fd1a189c2
--- /dev/null
+++ b/module/web/static/css/mobile/images/ajax-loader.gif
diff --git a/module/web/static/css/mobile/images/ajax-loader.png b/module/web/static/css/mobile/images/ajax-loader.png
new file mode 100644
index 000000000..13b208ddd
--- /dev/null
+++ b/module/web/static/css/mobile/images/ajax-loader.png
diff --git a/module/web/static/css/mobile/images/icons-18-black.png b/module/web/static/css/mobile/images/icons-18-black.png
new file mode 100644
index 000000000..ce1b758ad
--- /dev/null
+++ b/module/web/static/css/mobile/images/icons-18-black.png
diff --git a/module/web/static/css/mobile/images/icons-18-white.png b/module/web/static/css/mobile/images/icons-18-white.png
new file mode 100644
index 000000000..1ab012723
--- /dev/null
+++ b/module/web/static/css/mobile/images/icons-18-white.png
diff --git a/module/web/static/css/mobile/images/icons-36-black.png b/module/web/static/css/mobile/images/icons-36-black.png
new file mode 100644
index 000000000..1a59d7c37
--- /dev/null
+++ b/module/web/static/css/mobile/images/icons-36-black.png
diff --git a/module/web/static/css/mobile/images/icons-36-white.png b/module/web/static/css/mobile/images/icons-36-white.png
new file mode 100644
index 000000000..5647bdc94
--- /dev/null
+++ b/module/web/static/css/mobile/images/icons-36-white.png
diff --git a/module/web/static/css/mobile/jquery.mobile-1.1.1.min.css b/module/web/static/css/mobile/jquery.mobile-1.1.1.min.css
new file mode 100644
index 000000000..9aac54977
--- /dev/null
+++ b/module/web/static/css/mobile/jquery.mobile-1.1.1.min.css
@@ -0,0 +1,2 @@
+/*! jQuery Mobile v1.1.1 1981b3f5ec22675ae47df8f0bdf9622e7780e90e jquerymobile.com | jquery.org/license */
+.ui-bar-a{border:1px solid #333;background:#111;color:#fff;font-weight:bold;text-shadow:0 -1px 1px #000;background-image:-webkit-gradient(linear,left top,left bottom,from(#3c3c3c),to(#111));background-image:-webkit-linear-gradient(#3c3c3c,#111);background-image:-moz-linear-gradient(#3c3c3c,#111);background-image:-ms-linear-gradient(#3c3c3c,#111);background-image:-o-linear-gradient(#3c3c3c,#111);background-image:linear-gradient(#3c3c3c,#111)}.ui-bar-a,.ui-bar-a input,.ui-bar-a select,.ui-bar-a textarea,.ui-bar-a button{font-family:Helvetica,Arial,sans-serif}.ui-bar-a .ui-link-inherit{color:#fff}.ui-bar-a a.ui-link{color:#7cc4e7;font-weight:bold}.ui-bar-a a.ui-link:visited{color:#2489ce}.ui-bar-a a.ui-link:hover{color:#2489ce}.ui-bar-a a.ui-link:active{color:#2489ce}.ui-body-a,.ui-overlay-a{border:1px solid #444;background:#222;color:#fff;text-shadow:0 1px 1px #111;font-weight:normal;background-image:-webkit-gradient(linear,left top,left bottom,from(#444),to(#222));background-image:-webkit-linear-gradient(#444,#222);background-image:-moz-linear-gradient(#444,#222);background-image:-ms-linear-gradient(#444,#222);background-image:-o-linear-gradient(#444,#222);background-image:linear-gradient(#444,#222)}.ui-overlay-a{background-image:none;border-width:0}.ui-body-a,.ui-body-a input,.ui-body-a select,.ui-body-a textarea,.ui-body-a button{font-family:Helvetica,Arial,sans-serif}.ui-body-a .ui-link-inherit{color:#fff}.ui-body-a .ui-link{color:#2489ce;font-weight:bold}.ui-body-a .ui-link:visited{color:#2489ce}.ui-body-a .ui-link:hover{color:#2489ce}.ui-body-a .ui-link:active{color:#2489ce}.ui-btn-up-a{border:1px solid #111;background:#333;font-weight:bold;color:#fff;text-shadow:0 1px 1px #111;background-image:-webkit-gradient(linear,left top,left bottom,from(#444),to(#2d2d2d));background-image:-webkit-linear-gradient(#444,#2d2d2d);background-image:-moz-linear-gradient(#444,#2d2d2d);background-image:-ms-linear-gradient(#444,#2d2d2d);background-image:-o-linear-gradient(#444,#2d2d2d);background-image:linear-gradient(#444,#2d2d2d)}.ui-btn-up-a:visited,.ui-btn-up-a a.ui-link-inherit{color:#fff}.ui-btn-hover-a{border:1px solid #000;background:#444;font-weight:bold;color:#fff;text-shadow:0 1px 1px #111;background-image:-webkit-gradient(linear,left top,left bottom,from(#555),to(#383838));background-image:-webkit-linear-gradient(#555,#383838);background-image:-moz-linear-gradient(#555,#383838);background-image:-ms-linear-gradient(#555,#383838);background-image:-o-linear-gradient(#555,#383838);background-image:linear-gradient(#555,#383838)}.ui-btn-hover-a:visited,.ui-btn-hover-a:hover,.ui-btn-hover-a a.ui-link-inherit{color:#fff}.ui-btn-down-a{border:1px solid #000;background:#222;font-weight:bold;color:#fff;text-shadow:0 1px 1px #111;background-image:-webkit-gradient(linear,left top,left bottom,from(#202020),to(#2c2c2c));background-image:-webkit-linear-gradient(#202020,#2c2c2c);background-image:-moz-linear-gradient(#202020,#2c2c2c);background-image:-ms-linear-gradient(#202020,#2c2c2c);background-image:-o-linear-gradient(#202020,#2c2c2c);background-image:linear-gradient(#202020,#2c2c2c)}.ui-btn-down-a:visited,.ui-btn-down-a:hover,.ui-btn-down-a a.ui-link-inherit{color:#fff}.ui-btn-up-a,.ui-btn-hover-a,.ui-btn-down-a{font-family:Helvetica,Arial,sans-serif;text-decoration:none}.ui-bar-b{border:1px solid #456f9a;background:#5e87b0;color:#fff;font-weight:bold;text-shadow:0 1px 1px #3e6790;background-image:-webkit-gradient(linear,left top,left bottom,from(#6facd5),to(#497bae));background-image:-webkit-linear-gradient(#6facd5,#497bae);background-image:-moz-linear-gradient(#6facd5,#497bae);background-image:-ms-linear-gradient(#6facd5,#497bae);background-image:-o-linear-gradient(#6facd5,#497bae);background-image:linear-gradient(#6facd5,#497bae)}.ui-bar-b,.ui-bar-b input,.ui-bar-b select,.ui-bar-b textarea,.ui-bar-b button{font-family:Helvetica,Arial,sans-serif}.ui-bar-b .ui-link-inherit{color:#fff}.ui-bar-b a.ui-link{color:#ddf0f8;font-weight:bold}.ui-bar-b a.ui-link:visited{color:#ddf0f8}.ui-bar-b a.ui-link:hover{color:#ddf0f8}.ui-bar-b a.ui-link:active{color:#ddf0f8}.ui-body-b,.ui-overlay-b{border:1px solid #999;background:#f3f3f3;color:#222;text-shadow:0 1px 0 #fff;font-weight:normal;background-image:-webkit-gradient(linear,left top,left bottom,from(#ddd),to(#ccc));background-image:-webkit-linear-gradient(#ddd,#ccc);background-image:-moz-linear-gradient(#ddd,#ccc);background-image:-ms-linear-gradient(#ddd,#ccc);background-image:-o-linear-gradient(#ddd,#ccc);background-image:linear-gradient(#ddd,#ccc)}.ui-overlay-b{background-image:none;border-width:0}.ui-body-b,.ui-body-b input,.ui-body-b select,.ui-body-b textarea,.ui-body-b button{font-family:Helvetica,Arial,sans-serif}.ui-body-b .ui-link-inherit{color:#333}.ui-body-b .ui-link{color:#2489ce;font-weight:bold}.ui-body-b .ui-link:visited{color:#2489ce}.ui-body-b .ui-link:hover{color:#2489ce}.ui-body-b .ui-link:active{color:#2489ce}.ui-btn-up-b{border:1px solid #044062;background:#396b9e;font-weight:bold;color:#fff;text-shadow:0 1px 1px #194b7e;background-image:-webkit-gradient(linear,left top,left bottom,from(#5f9cc5),to(#396b9e));background-image:-webkit-linear-gradient(#5f9cc5,#396b9e);background-image:-moz-linear-gradient(#5f9cc5,#396b9e);background-image:-ms-linear-gradient(#5f9cc5,#396b9e);background-image:-o-linear-gradient(#5f9cc5,#396b9e);background-image:linear-gradient(#5f9cc5,#396b9e)}.ui-btn-up-b:visited,.ui-btn-up-b a.ui-link-inherit{color:#fff}.ui-btn-hover-b{border:1px solid #00415e;background:#4b88b6;font-weight:bold;color:#fff;text-shadow:0 1px 1px #194b7e;background-image:-webkit-gradient(linear,left top,left bottom,from(#6facd5),to(#4272a4));background-image:-webkit-linear-gradient(#6facd5,#4272a4);background-image:-moz-linear-gradient(#6facd5,#4272a4);background-image:-ms-linear-gradient(#6facd5,#4272a4);background-image:-o-linear-gradient(#6facd5,#4272a4);background-image:linear-gradient(#6facd5,#4272a4)}.ui-btn-hover-b:visited,.ui-btn-hover-a:hover,.ui-btn-hover-b a.ui-link-inherit{color:#fff}.ui-btn-down-b{border:1px solid #225377;background:#4e89c5;font-weight:bold;color:#fff;text-shadow:0 1px 1px #194b7e;background-image:-webkit-gradient(linear,left top,left bottom,from(#295b8e),to(#3e79b5));background-image:-webkit-linear-gradient(#295b8e,#3e79b5);background-image:-moz-linear-gradient(#295b8e,#3e79b5);background-image:-ms-linear-gradient(#295b8e,#3e79b5);background-image:-o-linear-gradient(#295b8e,#3e79b5);background-image:linear-gradient(#295b8e,#3e79b5)}.ui-btn-down-b:visited,.ui-btn-down-b:hover,.ui-btn-down-b a.ui-link-inherit{color:#fff}.ui-btn-up-b,.ui-btn-hover-b,.ui-btn-down-b{font-family:Helvetica,Arial,sans-serif;text-decoration:none}.ui-bar-c{border:1px solid #b3b3b3;background:#eee;color:#3e3e3e;font-weight:bold;text-shadow:0 1px 1px #fff;background-image:-webkit-gradient(linear,left top,left bottom,from(#f0f0f0),to(#ddd));background-image:-webkit-linear-gradient(#f0f0f0,#ddd);background-image:-moz-linear-gradient(#f0f0f0,#ddd);background-image:-ms-linear-gradient(#f0f0f0,#ddd);background-image:-o-linear-gradient(#f0f0f0,#ddd);background-image:linear-gradient(#f0f0f0,#ddd)}.ui-bar-c .ui-link-inherit{color:#3e3e3e}.ui-bar-c a.ui-link{color:#7cc4e7;font-weight:bold}.ui-bar-c a.ui-link:visited{color:#2489ce}.ui-bar-c a.ui-link:hover{color:#2489ce}.ui-bar-c a.ui-link:active{color:#2489ce}.ui-bar-c,.ui-bar-c input,.ui-bar-c select,.ui-bar-c textarea,.ui-bar-c button{font-family:Helvetica,Arial,sans-serif}.ui-body-c,.ui-overlay-c{border:1px solid #aaa;color:#333;text-shadow:0 1px 0 #fff;background:#f9f9f9;background-image:-webkit-gradient(linear,left top,left bottom,from(#f9f9f9),to(#eee));background-image:-webkit-linear-gradient(#f9f9f9,#eee);background-image:-moz-linear-gradient(#f9f9f9,#eee);background-image:-ms-linear-gradient(#f9f9f9,#eee);background-image:-o-linear-gradient(#f9f9f9,#eee);background-image:linear-gradient(#f9f9f9,#eee)}.ui-overlay-c{background-image:none;border-width:0}.ui-body-c,.ui-body-c input,.ui-body-c select,.ui-body-c textarea,.ui-body-c button{font-family:Helvetica,Arial,sans-serif}.ui-body-c .ui-link-inherit{color:#333}.ui-body-c .ui-link{color:#2489ce;font-weight:bold}.ui-body-c .ui-link:visited{color:#2489ce}.ui-body-c .ui-link:hover{color:#2489ce}.ui-body-c .ui-link:active{color:#2489ce}.ui-btn-up-c{border:1px solid #ccc;background:#eee;font-weight:bold;color:#222;text-shadow:0 1px 0 #fff;background-image:-webkit-gradient(linear,left top,left bottom,from(#fff),to(#f1f1f1));background-image:-webkit-linear-gradient(#fff,#f1f1f1);background-image:-moz-linear-gradient(#fff,#f1f1f1);background-image:-ms-linear-gradient(#fff,#f1f1f1);background-image:-o-linear-gradient(#fff,#f1f1f1);background-image:linear-gradient(#fff,#f1f1f1)}.ui-btn-up-c:visited,.ui-btn-up-c a.ui-link-inherit{color:#2f3e46}.ui-btn-hover-c{border:1px solid #bbb;background:#dfdfdf;font-weight:bold;color:#222;text-shadow:0 1px 0 #fff;background-image:-webkit-gradient(linear,left top,left bottom,from(#f6f6f6),to(#e0e0e0));background-image:-webkit-linear-gradient(#f6f6f6,#e0e0e0);background-image:-moz-linear-gradient(#f6f6f6,#e0e0e0);background-image:-ms-linear-gradient(#f6f6f6,#e0e0e0);background-image:-o-linear-gradient(#f6f6f6,#e0e0e0);background-image:linear-gradient(#f6f6f6,#e0e0e0)}.ui-btn-hover-c:visited,.ui-btn-hover-c:hover,.ui-btn-hover-c a.ui-link-inherit{color:#2f3e46}.ui-btn-down-c{border:1px solid #bbb;background:#d6d6d6;font-weight:bold;color:#222;text-shadow:0 1px 0 #fff;background-image:-webkit-gradient(linear,left top,left bottom,from(#d0d0d0),to(#dfdfdf));background-image:-webkit-linear-gradient(#d0d0d0,#dfdfdf);background-image:-moz-linear-gradient(#d0d0d0,#dfdfdf);background-image:-ms-linear-gradient(#d0d0d0,#dfdfdf);background-image:-o-linear-gradient(#d0d0d0,#dfdfdf);background-image:linear-gradient(#d0d0d0,#dfdfdf)}.ui-btn-down-c:visited,.ui-btn-down-c:hover,.ui-btn-down-c a.ui-link-inherit{color:#2f3e46}.ui-btn-up-c,.ui-btn-hover-c,.ui-btn-down-c{font-family:Helvetica,Arial,sans-serif;text-decoration:none}.ui-bar-d{border:1px solid #bbb;background:#bbb;color:#333;text-shadow:0 1px 0 #eee;background-image:-webkit-gradient(linear,left top,left bottom,from(#ddd),to(#bbb));background-image:-webkit-linear-gradient(#ddd,#bbb);background-image:-moz-linear-gradient(#ddd,#bbb);background-image:-ms-linear-gradient(#ddd,#bbb);background-image:-o-linear-gradient(#ddd,#bbb);background-image:linear-gradient(#ddd,#bbb)}.ui-bar-d,.ui-bar-d input,.ui-bar-d select,.ui-bar-d textarea,.ui-bar-d button{font-family:Helvetica,Arial,sans-serif}.ui-bar-d .ui-link-inherit{color:#333}.ui-bar-d a.ui-link{color:#2489ce;font-weight:bold}.ui-bar-d a.ui-link:visited{color:#2489ce}.ui-bar-d a.ui-link:hover{color:#2489ce}.ui-bar-d a.ui-link:active{color:#2489ce}.ui-body-d,.ui-overlay-d{border:1px solid #bbb;color:#333;text-shadow:0 1px 0 #fff;background:#fff;background-image:-webkit-gradient(linear,left top,left bottom,from(#fff),to(#fff));background-image:-webkit-linear-gradient(#fff,#fff);background-image:-moz-linear-gradient(#fff,#fff);background-image:-ms-linear-gradient(#fff,#fff);background-image:-o-linear-gradient(#fff,#fff);background-image:linear-gradient(#fff,#fff)}.ui-overlay-d{background-image:none;border-width:0}.ui-body-d,.ui-body-d input,.ui-body-d select,.ui-body-d textarea,.ui-body-d button{font-family:Helvetica,Arial,sans-serif}.ui-body-d .ui-link-inherit{color:#333}.ui-body-d .ui-link{color:#2489ce;font-weight:bold}.ui-body-d .ui-link:visited{color:#2489ce}.ui-body-d .ui-link:hover{color:#2489ce}.ui-body-d .ui-link:active{color:#2489ce}.ui-btn-up-d{border:1px solid #bbb;background:#fff;font-weight:bold;color:#333;text-shadow:0 1px 0 #fff;background-image:-webkit-gradient(linear,left top,left bottom,from(#fafafa),to(#f6f6f6));background-image:-webkit-linear-gradient(#fafafa,#f6f6f6);background-image:-moz-linear-gradient(#fafafa,#f6f6f6);background-image:-ms-linear-gradient(#fafafa,#f6f6f6);background-image:-o-linear-gradient(#fafafa,#f6f6f6);background-image:linear-gradient(#fafafa,#f6f6f6)}.ui-btn-up-d:visited,.ui-btn-up-d a.ui-link-inherit{color:#333}.ui-btn-hover-d{border:1px solid #aaa;background:#eee;font-weight:bold;color:#333;cursor:pointer;text-shadow:0 1px 0 #fff;background-image:-webkit-gradient(linear,left top,left bottom,from(#eee),to(#fff));background-image:-webkit-linear-gradient(#eee,#fff);background-image:-moz-linear-gradient(#eee,#fff);background-image:-ms-linear-gradient(#eee,#fff);background-image:-o-linear-gradient(#eee,#fff);background-image:linear-gradient(#eee,#fff)}.ui-btn-hover-d:visited,.ui-btn-hover-d:hover,.ui-btn-hover-d a.ui-link-inherit{color:#333}.ui-btn-down-d{border:1px solid #aaa;background:#eee;font-weight:bold;color:#333;text-shadow:0 1px 0 #fff;background-image:-webkit-gradient(linear,left top,left bottom,from(#e5e5e5),to(#f2f2f2));background-image:-webkit-linear-gradient(#e5e5e5,#f2f2f2);background-image:-moz-linear-gradient(#e5e5e5,#f2f2f2);background-image:-ms-linear-gradient(#e5e5e5,#f2f2f2);background-image:-o-linear-gradient(#e5e5e5,#f2f2f2);background-image:linear-gradient(#e5e5e5,#f2f2f2)}.ui-btn-down-d:visited,.ui-btn-down-d:hover,.ui-btn-down-d a.ui-link-inherit{color:#333}.ui-btn-up-d,.ui-btn-hover-d,.ui-btn-down-d{font-family:Helvetica,Arial,sans-serif;text-decoration:none}.ui-bar-e{border:1px solid #f7c942;background:#fadb4e;color:#333;text-shadow:0 1px 0 #fff;background-image:-webkit-gradient(linear,left top,left bottom,from(#fceda7),to(#fbef7e));background-image:-webkit-linear-gradient(#fceda7,#fbef7e);background-image:-moz-linear-gradient(#fceda7,#fbef7e);background-image:-ms-linear-gradient(#fceda7,#fbef7e);background-image:-o-linear-gradient(#fceda7,#fbef7e);background-image:linear-gradient(#fceda7,#fbef7e)}.ui-bar-e,.ui-bar-e input,.ui-bar-e select,.ui-bar-e textarea,.ui-bar-e button{font-family:Helvetica,Arial,sans-serif}.ui-bar-e .ui-link-inherit{color:#333}.ui-bar-e a.ui-link{color:#2489ce;font-weight:bold}.ui-bar-e a.ui-link:visited{color:#2489ce}.ui-bar-e a.ui-link:hover{color:#2489ce}.ui-bar-e a.ui-link:active{color:#2489ce}.ui-body-e,.ui-overlay-e{border:1px solid #f7c942;color:#222;text-shadow:0 1px 0 #fff;background:#fff9df;background-image:-webkit-gradient(linear,left top,left bottom,from(#fffadf),to(#fff3a5));background-image:-webkit-linear-gradient(#fffadf,#fff3a5);background-image:-moz-linear-gradient(#fffadf,#fff3a5);background-image:-ms-linear-gradient(#fffadf,#fff3a5);background-image:-o-linear-gradient(#fffadf,#fff3a5);background-image:linear-gradient(#fffadf,#fff3a5)}.ui-overlay-e{background-image:none;border-width:0}.ui-body-e,.ui-body-e input,.ui-body-e select,.ui-body-e textarea,.ui-body-e button{font-family:Helvetica,Arial,sans-serif}.ui-body-e .ui-link-inherit{color:#333}.ui-body-e .ui-link{color:#2489ce;font-weight:bold}.ui-body-e .ui-link:visited{color:#2489ce}.ui-body-e .ui-link:hover{color:#2489ce}.ui-body-e .ui-link:active{color:#2489ce}.ui-btn-up-e{border:1px solid #f4c63f;background:#fadb4e;font-weight:bold;color:#222;text-shadow:0 1px 0 #fff;background-image:-webkit-gradient(linear,left top,left bottom,from(#ffefaa),to(#ffe155));background-image:-webkit-linear-gradient(#ffefaa,#ffe155);background-image:-moz-linear-gradient(#ffefaa,#ffe155);background-image:-ms-linear-gradient(#ffefaa,#ffe155);background-image:-o-linear-gradient(#ffefaa,#ffe155);background-image:linear-gradient(#ffefaa,#ffe155)}.ui-btn-up-e:visited,.ui-btn-up-e a.ui-link-inherit{color:#222}.ui-btn-hover-e{border:1px solid #f2c43d;background:#fbe26f;font-weight:bold;color:#111;text-shadow:0 1px 0 #fff;background-image:-webkit-gradient(linear,left top,left bottom,from(#fff5ba),to(#fbdd52));background-image:-webkit-linear-gradient(#fff5ba,#fbdd52);background-image:-moz-linear-gradient(#fff5ba,#fbdd52);background-image:-ms-linear-gradient(#fff5ba,#fbdd52);background-image:-o-linear-gradient(#fff5ba,#fbdd52);background-image:linear-gradient(#fff5ba,#fbdd52)}.ui-btn-hover-e:visited,.ui-btn-hover-e:hover,.ui-btn-hover-e a.ui-link-inherit{color:#333}.ui-btn-down-e{border:1px solid #f2c43d;background:#fceda7;font-weight:bold;color:#111;text-shadow:0 1px 0 #fff;background-image:-webkit-gradient(linear,left top,left bottom,from(#f8d94c),to(#fadb4e));background-image:-webkit-linear-gradient(#f8d94c,#fadb4e);background-image:-moz-linear-gradient(#f8d94c,#fadb4e);background-image:-ms-linear-gradient(#f8d94c,#fadb4e);background-image:-o-linear-gradient(#f8d94c,#fadb4e);background-image:linear-gradient(#f8d94c,#fadb4e)}.ui-btn-down-e:visited,.ui-btn-down-e:hover,.ui-btn-down-e a.ui-link-inherit{color:#333}.ui-btn-up-e,.ui-btn-hover-e,.ui-btn-down-e{font-family:Helvetica,Arial,sans-serif;text-decoration:none}a.ui-link-inherit{text-decoration:none!important}.ui-btn-active{border:1px solid #2373a5;background:#5393c5;font-weight:bold;color:#fff;cursor:pointer;text-shadow:0 1px 1px #3373a5;text-decoration:none;background-image:-webkit-gradient(linear,left top,left bottom,from(#5393c5),to(#6facd5));background-image:-webkit-linear-gradient(#5393c5,#6facd5);background-image:-moz-linear-gradient(#5393c5,#6facd5);background-image:-ms-linear-gradient(#5393c5,#6facd5);background-image:-o-linear-gradient(#5393c5,#6facd5);background-image:linear-gradient(#5393c5,#6facd5);font-family:Helvetica,Arial,sans-serif}.ui-btn-active:visited,.ui-btn-active:hover,.ui-btn-active a.ui-link-inherit{color:#fff}.ui-btn-inner{border-top:1px solid #fff;border-color:rgba(255,255,255,.3)}.ui-corner-tl{-moz-border-radius-topleft:.6em;-webkit-border-top-left-radius:.6em;border-top-left-radius:.6em}.ui-corner-tr{-moz-border-radius-topright:.6em;-webkit-border-top-right-radius:.6em;border-top-right-radius:.6em}.ui-corner-bl{-moz-border-radius-bottomleft:.6em;-webkit-border-bottom-left-radius:.6em;border-bottom-left-radius:.6em}.ui-corner-br{-moz-border-radius-bottomright:.6em;-webkit-border-bottom-right-radius:.6em;border-bottom-right-radius:.6em}.ui-corner-top{-moz-border-radius-topleft:.6em;-webkit-border-top-left-radius:.6em;border-top-left-radius:.6em;-moz-border-radius-topright:.6em;-webkit-border-top-right-radius:.6em;border-top-right-radius:.6em}.ui-corner-bottom{-moz-border-radius-bottomleft:.6em;-webkit-border-bottom-left-radius:.6em;border-bottom-left-radius:.6em;-moz-border-radius-bottomright:.6em;-webkit-border-bottom-right-radius:.6em;border-bottom-right-radius:.6em}.ui-corner-right{-moz-border-radius-topright:.6em;-webkit-border-top-right-radius:.6em;border-top-right-radius:.6em;-moz-border-radius-bottomright:.6em;-webkit-border-bottom-right-radius:.6em;border-bottom-right-radius:.6em}.ui-corner-left{-moz-border-radius-topleft:.6em;-webkit-border-top-left-radius:.6em;border-top-left-radius:.6em;-moz-border-radius-bottomleft:.6em;-webkit-border-bottom-left-radius:.6em;border-bottom-left-radius:.6em}.ui-corner-all{-moz-border-radius:.6em;-webkit-border-radius:.6em;border-radius:.6em}.ui-corner-none{-moz-border-radius:0;-webkit-border-radius:0;border-radius:0}.ui-br{border-bottom:#828282;border-bottom:rgba(130,130,130,.3);border-bottom-width:1px;border-bottom-style:solid}.ui-disabled{opacity:.3}.ui-disabled,.ui-disabled a{cursor:default!important;pointer-events:none}.ui-disabled .ui-btn-text{-ms-filter:"alpha(opacity=30)";filter:alpha(opacity=30);zoom:1}.ui-icon,.ui-icon-searchfield:after{background:#666;background:rgba(0,0,0,.4);background-image:url(images/icons-18-white.png);background-repeat:no-repeat;-moz-border-radius:9px;-webkit-border-radius:9px;border-radius:9px}.ui-icon-alt{background:#fff;background:rgba(255,255,255,.3);background-image:url(images/icons-18-black.png);background-repeat:no-repeat}@media only screen and (-webkit-min-device-pixel-ratio:1.5),only screen and (min--moz-device-pixel-ratio:1.5),only screen and (min-resolution:240dpi){.ui-icon-plus,.ui-icon-minus,.ui-icon-delete,.ui-icon-arrow-r,.ui-icon-arrow-l,.ui-icon-arrow-u,.ui-icon-arrow-d,.ui-icon-check,.ui-icon-gear,.ui-icon-refresh,.ui-icon-forward,.ui-icon-back,.ui-icon-grid,.ui-icon-star,.ui-icon-alert,.ui-icon-info,.ui-icon-home,.ui-icon-search,.ui-icon-searchfield:after,.ui-icon-checkbox-off,.ui-icon-checkbox-on,.ui-icon-radio-off,.ui-icon-radio-on{background-image:url(images/icons-36-white.png);-moz-background-size:776px 18px;-o-background-size:776px 18px;-webkit-background-size:776px 18px;background-size:776px 18px}.ui-icon-alt{background-image:url(images/icons-36-black.png)}}.ui-icon-plus{background-position:-0 50%}.ui-icon-minus{background-position:-36px 50%}.ui-icon-delete{background-position:-72px 50%}.ui-icon-arrow-r{background-position:-108px 50%}.ui-icon-arrow-l{background-position:-144px 50%}.ui-icon-arrow-u{background-position:-180px 50%}.ui-icon-arrow-d{background-position:-216px 50%}.ui-icon-check{background-position:-252px 50%}.ui-icon-gear{background-position:-288px 50%}.ui-icon-refresh{background-position:-324px 50%}.ui-icon-forward{background-position:-360px 50%}.ui-icon-back{background-position:-396px 50%}.ui-icon-grid{background-position:-432px 50%}.ui-icon-star{background-position:-468px 50%}.ui-icon-alert{background-position:-504px 50%}.ui-icon-info{background-position:-540px 50%}.ui-icon-home{background-position:-576px 50%}.ui-icon-search,.ui-icon-searchfield:after{background-position:-612px 50%}.ui-icon-checkbox-off{background-position:-684px 50%}.ui-icon-checkbox-on{background-position:-648px 50%}.ui-icon-radio-off{background-position:-756px 50%}.ui-icon-radio-on{background-position:-720px 50%}.ui-checkbox .ui-icon{-moz-border-radius:3px;-webkit-border-radius:3px;border-radius:3px}.ui-icon-checkbox-off,.ui-icon-radio-off{background-color:transparent}.ui-checkbox-on .ui-icon,.ui-radio-on .ui-icon{background-color:#4596ce}.ui-icon-loading{background:url(images/ajax-loader.gif);background-size:46px 46px}.ui-btn-corner-tl{-moz-border-radius-topleft:1em;-webkit-border-top-left-radius:1em;border-top-left-radius:1em}.ui-btn-corner-tr{-moz-border-radius-topright:1em;-webkit-border-top-right-radius:1em;border-top-right-radius:1em}.ui-btn-corner-bl{-moz-border-radius-bottomleft:1em;-webkit-border-bottom-left-radius:1em;border-bottom-left-radius:1em}.ui-btn-corner-br{-moz-border-radius-bottomright:1em;-webkit-border-bottom-right-radius:1em;border-bottom-right-radius:1em}.ui-btn-corner-top{-moz-border-radius-topleft:1em;-webkit-border-top-left-radius:1em;border-top-left-radius:1em;-moz-border-radius-topright:1em;-webkit-border-top-right-radius:1em;border-top-right-radius:1em}.ui-btn-corner-bottom{-moz-border-radius-bottomleft:1em;-webkit-border-bottom-left-radius:1em;border-bottom-left-radius:1em;-moz-border-radius-bottomright:1em;-webkit-border-bottom-right-radius:1em;border-bottom-right-radius:1em}.ui-btn-corner-right{-moz-border-radius-topright:1em;-webkit-border-top-right-radius:1em;border-top-right-radius:1em;-moz-border-radius-bottomright:1em;-webkit-border-bottom-right-radius:1em;border-bottom-right-radius:1em}.ui-btn-corner-left{-moz-border-radius-topleft:1em;-webkit-border-top-left-radius:1em;border-top-left-radius:1em;-moz-border-radius-bottomleft:1em;-webkit-border-bottom-left-radius:1em;border-bottom-left-radius:1em}.ui-btn-corner-all{-moz-border-radius:1em;-webkit-border-radius:1em;border-radius:1em}.ui-corner-tl,.ui-corner-tr,.ui-corner-bl,.ui-corner-br,.ui-corner-top,.ui-corner-bottom,.ui-corner-right,.ui-corner-left,.ui-corner-all,.ui-btn-corner-tl,.ui-btn-corner-tr,.ui-btn-corner-bl,.ui-btn-corner-br,.ui-btn-corner-top,.ui-btn-corner-bottom,.ui-btn-corner-right,.ui-btn-corner-left,.ui-btn-corner-all{-webkit-background-clip:padding-box;-moz-background-clip:padding;background-clip:padding-box}.ui-overlay{background:#666;opacity:.5;filter:Alpha(Opacity=50);position:absolute;width:100%;height:100%}.ui-overlay-shadow{-moz-box-shadow:0 0 12px rgba(0,0,0,.6);-webkit-box-shadow:0 0 12px rgba(0,0,0,.6);box-shadow:0 0 12px rgba(0,0,0,.6)}.ui-shadow{-moz-box-shadow:0 1px 4px rgba(0,0,0,.3);-webkit-box-shadow:0 1px 4px rgba(0,0,0,.3);box-shadow:0 1px 4px rgba(0,0,0,.3)}.ui-bar-a .ui-shadow,.ui-bar-b .ui-shadow,.ui-bar-c .ui-shadow{-moz-box-shadow:0 1px 0 rgba(255,255,255,.3);-webkit-box-shadow:0 1px 0 rgba(255,255,255,.3);box-shadow:0 1px 0 rgba(255,255,255,.3)}.ui-shadow-inset{-moz-box-shadow:inset 0 1px 4px rgba(0,0,0,.2);-webkit-box-shadow:inset 0 1px 4px rgba(0,0,0,.2);box-shadow:inset 0 1px 4px rgba(0,0,0,.2)}.ui-icon-shadow{-moz-box-shadow:0 1px 0 rgba(255,255,255,.4);-webkit-box-shadow:0 1px 0 rgba(255,255,255,.4);box-shadow:0 1px 0 rgba(255,255,255,.4)}.ui-btn:focus,.ui-link-inherit:focus{outline:0}.ui-btn.ui-focus{z-index:1}.ui-focus,.ui-btn:focus{-moz-box-shadow:inset 0 0 3px #387bbe,0px 0 9px #387bbe;-webkit-box-shadow:inset 0 0 3px #387bbe,0px 0 9px #387bbe;box-shadow:inset 0 0 3px #387bbe,0px 0 9px #387bbe}.ui-input-text.ui-focus,.ui-input-search.ui-focus{-moz-box-shadow:0 0 12px #387bbe;-webkit-box-shadow:0 0 12px #387bbe;box-shadow:0 0 12px #387bbe}.ui-mobile-nosupport-boxshadow *{-moz-box-shadow:none!important;-webkit-box-shadow:none!important;box-shadow:none!important}.ui-mobile-nosupport-boxshadow .ui-focus,.ui-mobile-nosupport-boxshadow .ui-btn:focus,.ui-mobile-nosupport-boxshadow .ui-link-inherit:focus{outline-width:1px;outline-style:auto}.ui-mobile,.ui-mobile body{height:99.9%}.ui-mobile fieldset,.ui-page{padding:0;margin:0}.ui-mobile a img,.ui-mobile fieldset{border-width:0}.ui-mobile-viewport{margin:0;overflow-x:visible;-webkit-text-size-adjust:none;-ms-text-size-adjust:none;-webkit-tap-highlight-color:rgba(0,0,0,0)}body.ui-mobile-viewport,div.ui-mobile-viewport{overflow-x:hidden}.ui-mobile [data-role=page],.ui-mobile [data-role=dialog],.ui-page{top:0;left:0;width:100%;min-height:100%;position:absolute;display:none;border:0}.ui-mobile .ui-page-active{display:block;overflow:visible}.ui-page{outline:0}@media screen and (orientation:portrait){.ui-mobile,.ui-mobile .ui-page{min-height:420px}}@media screen and (orientation:landscape){.ui-mobile,.ui-mobile .ui-page{min-height:300px}}.ui-loading .ui-loader{display:block}.ui-loader{display:none;z-index:9999999;position:fixed;top:50%;left:50%;border:0}.ui-loader-default{background:0;opacity:.18;width:46px;height:46px;margin-left:-23px;margin-top:-23px}.ui-loader-verbose{width:200px;opacity:.88;box-shadow:0 1px 1px -1px #fff;height:auto;margin-left:-110px;margin-top:-43px;padding:10px}.ui-loader-default h1{font-size:0;width:0;height:0;overflow:hidden}.ui-loader-verbose h1{font-size:16px;margin:0;text-align:center}.ui-loader .ui-icon{background-color:#000;display:block;margin:0;width:44px;height:44px;padding:1px;-webkit-border-radius:36px;-moz-border-radius:36px;border-radius:36px}.ui-loader-verbose .ui-icon{margin:0 auto 10px;opacity:.75}.ui-loader-textonly{padding:15px;margin-left:-115px}.ui-loader-textonly .ui-icon{display:none}.ui-loader-fakefix{position:absolute}.ui-mobile-rendering>*{visibility:hidden}.ui-bar,.ui-body{position:relative;padding:.4em 15px;overflow:hidden;display:block;clear:both}.ui-bar{font-size:16px;margin:0}.ui-bar h1,.ui-bar h2,.ui-bar h3,.ui-bar h4,.ui-bar h5,.ui-bar h6{margin:0;padding:0;font-size:16px;display:inline-block}.ui-header,.ui-footer{position:relative;border-left-width:0;border-right-width:0;zoom:1}.ui-header .ui-btn-left,.ui-header .ui-btn-right,.ui-footer .ui-btn-left,.ui-footer .ui-btn-right{position:absolute;top:3px}.ui-header .ui-btn-left,.ui-footer .ui-btn-left{left:5px}.ui-header .ui-btn-right,.ui-footer .ui-btn-right{right:5px}.ui-footer .ui-btn-icon-notext,.ui-header .ui-btn-icon-notext{top:6px}.ui-header .ui-title,.ui-footer .ui-title{min-height:1.1em;text-align:center;font-size:16px;display:block;margin:.6em 30% .8em;padding:0;text-overflow:ellipsis;overflow:hidden;white-space:nowrap;outline:0!important}.ui-footer .ui-title{margin:.6em 15px .8em}.ui-content{border-width:0;overflow:visible;overflow-x:hidden;padding:15px}.ui-icon{width:18px;height:18px}.ui-nojs{position:absolute;left:-9999px}.ui-hide-label label.ui-input-text,.ui-hide-label label.ui-select,.ui-hide-label label.ui-slider,.ui-hide-label label.ui-submit,.ui-hide-label .ui-controlgroup-label,.ui-hidden-accessible{position:absolute!important;left:-9999px;clip:rect(1px 1px 1px 1px);clip:rect(1px,1px,1px,1px)}.ui-mobile-viewport-transitioning,.ui-mobile-viewport-transitioning .ui-page{width:100%;height:100%;overflow:hidden;-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}.in{-webkit-animation-timing-function:ease-out;-webkit-animation-duration:200ms !important;-moz-animation-timing-function:ease-out;-moz-animation-duration:200ms !important}.out{-webkit-animation-timing-function:ease-in;-webkit-animation-duration:225ms;-moz-animation-timing-function:ease-in;-moz-animation-duration:225}@-webkit-keyframes fadein{from{opacity:0}to{opacity:1}}@-moz-keyframes fadein{from{opacity:0}to{opacity:1}}@-webkit-keyframes fadeout{from{opacity:1}to{opacity:0}}@-moz-keyframes fadeout{from{opacity:1}to{opacity:0}}.fade.out{opacity:0;-webkit-animation-duration:125ms;-webkit-animation-name:fadeout;-moz-animation-duration:125ms;-moz-animation-name:fadeout}.fade.in{opacity:1;-webkit-animation-duration:225ms;-webkit-animation-name:fadein;-moz-animation-duration:225ms;-moz-animation-name:fadein}.pop{-webkit-transform-origin:50% 50%;-moz-transform-origin:50% 50%}.pop.in{-webkit-transform:scale(1);-moz-transform:scale(1);opacity:1;-webkit-animation-name:popin;-moz-animation-name:popin;-webkit-animation-duration:350ms;-moz-animation-duration:350ms}.pop.out{-webkit-animation-name:fadeout;-moz-animation-name:fadeout;opacity:0;-webkit-animation-duration:100ms;-moz-animation-duration:100ms}.pop.in.reverse{-webkit-animation-name:fadein;-moz-animation-name:fadein}.pop.out.reverse{-webkit-transform:scale(.8);-moz-transform:scale(.8);-webkit-animation-name:popout;-moz-animation-name:popout}@-webkit-keyframes popin{from{-webkit-transform:scale(.8);opacity:0}to{-webkit-transform:scale(1);opacity:1}}@-moz-keyframes popin{from{-moz-transform:scale(.8);opacity:0}to{-moz-transform:scale(1);opacity:1}}@-webkit-keyframes popout{from{-webkit-transform:scale(1);opacity:1}to{-webkit-transform:scale(.8);opacity:0}}@-moz-keyframes popout{from{-moz-transform:scale(1);opacity:1}to{-moz-transform:scale(.8);opacity:0}}@-webkit-keyframes slideinfromright{from{-webkit-transform:translateX(100%)}to{-webkit-transform:translateX(0)}}@-moz-keyframes slideinfromright{from{-moz-transform:translateX(100%)}to{-moz-transform:translateX(0)}}@-webkit-keyframes slideinfromleft{from{-webkit-transform:translateX(-100%)}to{-webkit-transform:translateX(0)}}@-moz-keyframes slideinfromleft{from{-moz-transform:translateX(-100%)}to{-moz-transform:translateX(0)}}@-webkit-keyframes slideouttoleft{from{-webkit-transform:translateX(0)}to{-webkit-transform:translateX(-100%)}}@-moz-keyframes slideouttoleft{from{-moz-transform:translateX(0)}to{-moz-transform:translateX(-100%)}}@-webkit-keyframes slideouttoright{from{-webkit-transform:translateX(0)}to{-webkit-transform:translateX(100%)}}@-moz-keyframes slideouttoright{from{-moz-transform:translateX(0)}to{-moz-transform:translateX(100%)}}.slide.out,.slide.in{-webkit-animation-timing-function:ease-out;-webkit-animation-duration:350ms;-moz-animation-timing-function:ease-out;-moz-animation-duration:350ms}.slide.out{-webkit-transform:translateX(-100%);-webkit-animation-name:slideouttoleft;-moz-transform:translateX(-100%);-moz-animation-name:slideouttoleft}.slide.in{-webkit-transform:translateX(0);-webkit-animation-name:slideinfromright;-moz-transform:translateX(0);-moz-animation-name:slideinfromright}.slide.out.reverse{-webkit-transform:translateX(100%);-webkit-animation-name:slideouttoright;-moz-transform:translateX(100%);-moz-animation-name:slideouttoright}.slide.in.reverse{-webkit-transform:translateX(0);-webkit-animation-name:slideinfromleft;-moz-transform:translateX(0);-moz-animation-name:slideinfromleft}.slidefade.out{-webkit-transform:translateX(-100%);-webkit-animation-name:slideouttoleft;-moz-transform:translateX(-100%);-moz-animation-name:slideouttoleft;-webkit-animation-duration:225ms;-moz-animation-duration:225ms}.slidefade.in{-webkit-transform:translateX(0);-webkit-animation-name:fadein;-moz-transform:translateX(0);-moz-animation-name:fadein;-webkit-animation-duration:200ms;-moz-animation-duration:200ms}.slidefade.out.reverse{-webkit-transform:translateX(100%);-webkit-animation-name:slideouttoright;-moz-transform:translateX(100%);-moz-animation-name:slideouttoright;-webkit-animation-duration:200ms;-moz-animation-duration:200ms}.slidefade.in.reverse{-webkit-transform:translateX(0);-webkit-animation-name:fadein;-moz-transform:translateX(0);-moz-animation-name:fadein;-webkit-animation-duration:200ms;-moz-animation-duration:200ms}.slidedown.out{-webkit-animation-name:fadeout;-moz-animation-name:fadeout;-webkit-animation-duration:100ms;-moz-animation-duration:100ms}.slidedown.in{-webkit-transform:translateY(0);-webkit-animation-name:slideinfromtop;-moz-transform:translateY(0);-moz-animation-name:slideinfromtop;-webkit-animation-duration:250ms;-moz-animation-duration:250ms}.slidedown.in.reverse{-webkit-animation-name:fadein;-moz-animation-name:fadein;-webkit-animation-duration:150ms;-moz-animation-duration:150ms}.slidedown.out.reverse{-webkit-transform:translateY(-100%);-moz-transform:translateY(-100%);-webkit-animation-name:slideouttotop;-moz-animation-name:slideouttotop;-webkit-animation-duration:200ms;-moz-animation-duration:200ms}@-webkit-keyframes slideinfromtop{from{-webkit-transform:translateY(-100%)}to{-webkit-transform:translateY(0)}}@-moz-keyframes slideinfromtop{from{-moz-transform:translateY(-100%)}to{-moz-transform:translateY(0)}}@-webkit-keyframes slideouttotop{from{-webkit-transform:translateY(0)}to{-webkit-transform:translateY(-100%)}}@-moz-keyframes slideouttotop{from{-moz-transform:translateY(0)}to{-moz-transform:translateY(-100%)}}.slideup.out{-webkit-animation-name:fadeout;-moz-animation-name:fadeout;-webkit-animation-duration:100ms;-moz-animation-duration:100ms}.slideup.in{-webkit-transform:translateY(0);-webkit-animation-name:slideinfrombottom;-moz-transform:translateY(0);-moz-animation-name:slideinfrombottom;-webkit-animation-duration:250ms;-moz-animation-duration:250ms}.slideup.in.reverse{-webkit-animation-name:fadein;-moz-animation-name:fadein;-webkit-animation-duration:150ms;-moz-animation-duration:150ms}.slideup.out.reverse{-webkit-transform:translateY(100%);-moz-transform:translateY(100%);-webkit-animation-name:slideouttobottom;-moz-animation-name:slideouttobottom;-webkit-animation-duration:200ms;-moz-animation-duration:200ms}@-webkit-keyframes slideinfrombottom{from{-webkit-transform:translateY(100%)}to{-webkit-transform:translateY(0)}}@-moz-keyframes slideinfrombottom{from{-moz-transform:translateY(100%)}to{-moz-transform:translateY(0)}}@-webkit-keyframes slideouttobottom{from{-webkit-transform:translateY(0)}to{-webkit-transform:translateY(100%)}}@-moz-keyframes slideouttobottom{from{-moz-transform:translateY(0)}to{-moz-transform:translateY(100%)}}.viewport-flip{-webkit-perspective:1000;-moz-perspective:1000;position:absolute}.flip{-webkit-backface-visibility:hidden;-webkit-transform:translateX(0);-moz-backface-visibility:hidden;-moz-transform:translateX(0)}.flip.out{-webkit-transform:rotateY(-90deg) scale(.9);-webkit-animation-name:flipouttoleft;-webkit-animation-duration:175ms;-moz-transform:rotateY(-90deg) scale(.9);-moz-animation-name:flipouttoleft;-moz-animation-duration:175ms}.flip.in{-webkit-animation-name:flipintoright;-webkit-animation-duration:225ms;-moz-animation-name:flipintoright;-moz-animation-duration:225ms}.flip.out.reverse{-webkit-transform:rotateY(90deg) scale(.9);-webkit-animation-name:flipouttoright;-moz-transform:rotateY(90deg) scale(.9);-moz-animation-name:flipouttoright}.flip.in.reverse{-webkit-animation-name:flipintoleft;-moz-animation-name:flipintoleft}@-webkit-keyframes flipouttoleft{from{-webkit-transform:rotateY(0)}to{-webkit-transform:rotateY(-90deg) scale(.9)}}@-moz-keyframes flipouttoleft{from{-moz-transform:rotateY(0)}to{-moz-transform:rotateY(-90deg) scale(.9)}}@-webkit-keyframes flipouttoright{from{-webkit-transform:rotateY(0)}to{-webkit-transform:rotateY(90deg) scale(.9)}}@-moz-keyframes flipouttoright{from{-moz-transform:rotateY(0)}to{-moz-transform:rotateY(90deg) scale(.9)}}@-webkit-keyframes flipintoleft{from{-webkit-transform:rotateY(-90deg) scale(.9)}to{-webkit-transform:rotateY(0)}}@-moz-keyframes flipintoleft{from{-moz-transform:rotateY(-90deg) scale(.9)}to{-moz-transform:rotateY(0)}}@-webkit-keyframes flipintoright{from{-webkit-transform:rotateY(90deg) scale(.9)}to{-webkit-transform:rotateY(0)}}@-moz-keyframes flipintoright{from{-moz-transform:rotateY(90deg) scale(.9)}to{-moz-transform:rotateY(0)}}.viewport-turn{-webkit-perspective:1000;-moz-perspective:1000;position:absolute}.turn{-webkit-backface-visibility:hidden;-webkit-transform:translateX(0);-webkit-transform-origin:0 0;-moz-backface-visibility:hidden;-moz-transform:translateX(0);-moz-transform-origin:0 0}.turn.out{-webkit-transform:rotateY(-90deg) scale(.9);-webkit-animation-name:flipouttoleft;-moz-transform:rotateY(-90deg) scale(.9);-moz-animation-name:flipouttoleft;-webkit-animation-duration:125ms;-moz-animation-duration:125ms}.turn.in{-webkit-animation-name:flipintoright;-moz-animation-name:flipintoright;-webkit-animation-duration:250ms;-moz-animation-duration:250ms}.turn.out.reverse{-webkit-transform:rotateY(90deg) scale(.9);-webkit-animation-name:flipouttoright;-moz-transform:rotateY(90deg) scale(.9);-moz-animation-name:flipouttoright}.turn.in.reverse{-webkit-animation-name:flipintoleft;-moz-animation-name:flipintoleft}@-webkit-keyframes flipouttoleft{from{-webkit-transform:rotateY(0)}to{-webkit-transform:rotateY(-90deg) scale(.9)}}@-moz-keyframes flipouttoleft{from{-moz-transform:rotateY(0)}to{-moz-transform:rotateY(-90deg) scale(.9)}}@-webkit-keyframes flipouttoright{from{-webkit-transform:rotateY(0)}to{-webkit-transform:rotateY(90deg) scale(.9)}}@-moz-keyframes flipouttoright{from{-moz-transform:rotateY(0)}to{-moz-transform:rotateY(90deg) scale(.9)}}@-webkit-keyframes flipintoleft{from{-webkit-transform:rotateY(-90deg) scale(.9)}to{-webkit-transform:rotateY(0)}}@-moz-keyframes flipintoleft{from{-moz-transform:rotateY(-90deg) scale(.9)}to{-moz-transform:rotateY(0)}}@-webkit-keyframes flipintoright{from{-webkit-transform:rotateY(90deg) scale(.9)}to{-webkit-transform:rotateY(0)}}@-moz-keyframes flipintoright{from{-moz-transform:rotateY(90deg) scale(.9)}to{-moz-transform:rotateY(0)}}.flow{-webkit-transform-origin:50% 30%;-moz-transform-origin:50% 30%;-webkit-box-shadow:0 0 20px rgba(0,0,0,.4);-moz-box-shadow:0 0 20px rgba(0,0,0,.4)}.ui-dialog.flow{-webkit-transform-origin:none;-moz-transform-origin:none;-webkit-box-shadow:none;-moz-box-shadow:none}.flow.out{-webkit-transform:translateX(-100%) scale(.7);-webkit-animation-name:flowouttoleft;-webkit-animation-timing-function:ease;-webkit-animation-duration:350ms;-moz-transform:translateX(-100%) scale(.7);-moz-animation-name:flowouttoleft;-moz-animation-timing-function:ease;-moz-animation-duration:350ms}.flow.in{-webkit-transform:translateX(0) scale(1);-webkit-animation-name:flowinfromright;-webkit-animation-timing-function:ease;-webkit-animation-duration:350ms;-moz-transform:translateX(0) scale(1);-moz-animation-name:flowinfromright;-moz-animation-timing-function:ease;-moz-animation-duration:350ms}.flow.out.reverse{-webkit-transform:translateX(100%);-webkit-animation-name:flowouttoright;-moz-transform:translateX(100%);-moz-animation-name:flowouttoright}.flow.in.reverse{-webkit-animation-name:flowinfromleft;-moz-animation-name:flowinfromleft}@-webkit-keyframes flowouttoleft{0%{-webkit-transform:translateX(0) scale(1)}60%,70%{-webkit-transform:translateX(0) scale(.7)}100%{-webkit-transform:translateX(-100%) scale(.7)}}@-moz-keyframes flowouttoleft{0%{-moz-transform:translateX(0) scale(1)}60%,70%{-moz-transform:translateX(0) scale(.7)}100%{-moz-transform:translateX(-100%) scale(.7)}}@-webkit-keyframes flowouttoright{0%{-webkit-transform:translateX(0) scale(1)}60%,70%{-webkit-transform:translateX(0) scale(.7)}100%{-webkit-transform:translateX(100%) scale(.7)}}@-moz-keyframes flowouttoright{0%{-moz-transform:translateX(0) scale(1)}60%,70%{-moz-transform:translateX(0) scale(.7)}100%{-moz-transform:translateX(100%) scale(.7)}}@-webkit-keyframes flowinfromleft{0%{-webkit-transform:translateX(-100%) scale(.7)}30%,40%{-webkit-transform:translateX(0) scale(.7)}100%{-webkit-transform:translateX(0) scale(1)}}@-moz-keyframes flowinfromleft{0%{-moz-transform:translateX(-100%) scale(.7)}30%,40%{-moz-transform:translateX(0) scale(.7)}100%{-moz-transform:translateX(0) scale(1)}}@-webkit-keyframes flowinfromright{0%{-webkit-transform:translateX(100%) scale(.7)}30%,40%{-webkit-transform:translateX(0) scale(.7)}100%{-webkit-transform:translateX(0) scale(1)}}@-moz-keyframes flowinfromright{0%{-moz-transform:translateX(100%) scale(.7)}30%,40%{-moz-transform:translateX(0) scale(.7)}100%{-moz-transform:translateX(0) scale(1)}}.ui-grid-a,.ui-grid-b,.ui-grid-c,.ui-grid-d{overflow:hidden}.ui-block-a,.ui-block-b,.ui-block-c,.ui-block-d,.ui-block-e{margin:0;padding:0;border:0;float:left;min-height:1px;-webkit-box-sizing:border-box;-moz-box-sizing:border-box;-ms-box-sizing:border-box;box-sizing:border-box}.ui-grid-solo .ui-block-a{display:block;float:none}.ui-grid-a .ui-block-a,.ui-grid-a .ui-block-b{width:49.95%}.ui-grid-a>:nth-child(n){width:50%;margin-right:-.5px}.ui-grid-a .ui-block-a{clear:left}.ui-grid-b .ui-block-a,.ui-grid-b .ui-block-b,.ui-grid-b .ui-block-c{width:33.25%}.ui-grid-b>:nth-child(n){width:33.333%;margin-right:-.5px}.ui-grid-b .ui-block-a{clear:left}.ui-grid-c .ui-block-a,.ui-grid-c .ui-block-b,.ui-grid-c .ui-block-c,.ui-grid-c .ui-block-d{width:24.925%}.ui-grid-c>:nth-child(n){width:25%;margin-right:-.5px}.ui-grid-c .ui-block-a{clear:left}.ui-grid-d .ui-block-a,.ui-grid-d .ui-block-b,.ui-grid-d .ui-block-c,.ui-grid-d .ui-block-d,.ui-grid-d .ui-block-e{width:19.925%}.ui-grid-d>:nth-child(n){width:20%}.ui-grid-d .ui-block-a{clear:left}.ui-header-fixed,.ui-footer-fixed{left:0;right:0;width:100%;position:fixed;z-index:1000}.ui-page-pre-in{opacity:0}.ui-header-fixed{top:0}.ui-footer-fixed{bottom:0}.ui-header-fullscreen,.ui-footer-fullscreen{opacity:.9}.ui-page-header-fixed{padding-top:2.6875em}.ui-page-footer-fixed{padding-bottom:2.6875em}.ui-page-header-fullscreen .ui-content,.ui-page-footer-fullscreen .ui-content{padding:0}.ui-fixed-hidden{position:absolute}.ui-page-header-fullscreen .ui-fixed-hidden,.ui-page-footer-fullscreen .ui-fixed-hidden{left:-99999em}.ui-header-fixed .ui-btn,.ui-footer-fixed .ui-btn{z-index:10}.ui-navbar{max-width:100%}.ui-navbar ul{list-style:none;margin:0;padding:0;position:relative;display:block;border:0;max-width:100%;overflow:hidden}.ui-navbar li .ui-btn{display:block;text-align:center;margin:0 -1px 0 0;border-right-width:0}.ui-navbar li .ui-btn-icon-right .ui-icon{right:6px}.ui-navbar li:last-child .ui-btn,.ui-navbar .ui-grid-duo .ui-block-b .ui-btn{margin-right:0;border-right-width:1px}.ui-header .ui-navbar li:last-child .ui-btn,.ui-footer .ui-navbar li:last-child .ui-btn,.ui-header .ui-navbar .ui-grid-duo .ui-block-b .ui-btn,.ui-footer .ui-navbar .ui-grid-duo .ui-block-b .ui-btn{margin-right:-1px;border-right-width:0}.ui-navbar .ui-grid-duo li.ui-block-a:last-child .ui-btn{margin-right:-1px;border-right-width:1px}.ui-header .ui-navbar li .ui-btn,.ui-footer .ui-navbar li .ui-btn{border-top-width:0;border-bottom-width:0}.ui-header .ui-navbar .ui-grid-b li.ui-block-c .ui-btn,.ui-footer .ui-navbar .ui-grid-b li.ui-block-c .ui-btn{margin-right:-5px}.ui-header .ui-navbar .ui-grid-c li.ui-block-d .ui-btn,.ui-footer .ui-navbar .ui-grid-c li.ui-block-d .ui-btn,.ui-header .ui-navbar .ui-grid-d li.ui-block-e .ui-btn,.ui-footer .ui-navbar .ui-grid-d li.ui-block-e .ui-btn{margin-right:-4px}.ui-header .ui-navbar .ui-grid-b li.ui-block-c .ui-btn-icon-right .ui-icon,.ui-footer .ui-navbar .ui-grid-b li.ui-block-c .ui-btn-icon-right .ui-icon,.ui-header .ui-navbar .ui-grid-c li.ui-block-d .ui-btn-icon-right .ui-icon,.ui-footer .ui-navbar .ui-grid-c li.ui-block-d .ui-btn-icon-right .ui-icon,.ui-header .ui-navbar .ui-grid-d li.ui-block-e .ui-btn-icon-right .ui-icon,.ui-footer .ui-navbar .ui-grid-d li.ui-block-e .ui-btn-icon-right .ui-icon{right:8px}.ui-navbar li .ui-btn .ui-btn-inner{padding-top:.7em;padding-bottom:.8em}.ui-navbar li .ui-btn-icon-top .ui-btn-inner{padding-top:30px}.ui-navbar li .ui-btn-icon-bottom .ui-btn-inner{padding-bottom:30px}.ui-btn{display:block;text-align:center;cursor:pointer;position:relative;margin:.5em 0;padding:0}.ui-btn.ui-mini{margin-top:.25em;margin-bottom:.25em}.ui-btn-left,.ui-btn-right,.ui-input-clear,.ui-btn-inline,.ui-grid-a .ui-btn,.ui-grid-b .ui-btn,.ui-grid-c .ui-btn,.ui-grid-d .ui-btn,.ui-grid-e .ui-btn,.ui-grid-solo .ui-btn{margin-right:5px;margin-left:5px}.ui-btn-inner{font-size:16px;padding:.6em 20px;min-width:.75em;display:block;position:relative;text-overflow:ellipsis;overflow:hidden;white-space:nowrap;zoom:1}.ui-btn input,.ui-btn button{z-index:2}.ui-btn-left,.ui-btn-right,.ui-btn-inline{display:inline-block;vertical-align:middle}.ui-btn-block{display:block}.ui-header .ui-btn,.ui-footer .ui-btn{display:inline-block;margin:0}.ui-header .ui-btn-block,.ui-footer .ui-btn-block{display:block}.ui-header .ui-btn-inner,.ui-footer .ui-btn-inner,.ui-mini .ui-btn-inner{font-size:12.5px;padding:.55em 11px .5em}.ui-header .ui-fullsize .ui-btn-inner,.ui-footer .ui-fullsize .ui-btn-inner{font-size:16px;padding:.6em 25px}.ui-btn-icon-notext{width:24px;height:24px}.ui-btn-icon-notext .ui-btn-inner{padding:0;height:100%}.ui-btn-icon-notext .ui-btn-inner .ui-icon{margin:2px 1px 2px 3px;float:left}.ui-btn-text{position:relative;z-index:1;width:100%;-moz-user-select:none;-webkit-user-select:none;-ms-user-select:none}.ui-btn-icon-notext .ui-btn-text{position:absolute;left:-9999px}.ui-btn-icon-left .ui-btn-inner{padding-left:40px}.ui-btn-icon-right .ui-btn-inner{padding-right:40px}.ui-btn-icon-top .ui-btn-inner{padding-top:40px}.ui-btn-icon-bottom .ui-btn-inner{padding-bottom:40px}.ui-header .ui-btn-icon-left .ui-btn-inner,.ui-footer .ui-btn-icon-left .ui-btn-inner,.ui-mini.ui-btn-icon-left .ui-btn-inner,.ui-mini .ui-btn-icon-left .ui-btn-inner{padding-left:30px}.ui-header .ui-btn-icon-right .ui-btn-inner,.ui-footer .ui-btn-icon-right .ui-btn-inner,.ui-mini.ui-btn-icon-right .ui-btn-inner,.ui-mini .ui-btn-icon-right .ui-btn-inner{padding-right:30px}.ui-header .ui-btn-icon-top .ui-btn-inner,.ui-footer .ui-btn-icon-top .ui-btn-inner{padding:30px 3px .5em 3px}.ui-mini.ui-btn-icon-top .ui-btn-inner,.ui-mini .ui-btn-icon-top .ui-btn-inner{padding-top:30px}.ui-header .ui-btn-icon-bottom .ui-btn-inner,.ui-footer .ui-btn-icon-bottom .ui-btn-inner{padding:.55em 3px 30px 3px}.ui-mini.ui-btn-icon-bottom .ui-btn-inner,.ui-mini .ui-btn-icon-bottom .ui-btn-inner{padding-bottom:30px}.ui-btn-icon-notext .ui-icon{display:block;z-index:0}.ui-btn-icon-left>.ui-btn-inner>.ui-icon,.ui-btn-icon-right>.ui-btn-inner>.ui-icon{position:absolute;top:50%;margin-top:-9px}.ui-btn-icon-top .ui-btn-inner .ui-icon,.ui-btn-icon-bottom .ui-btn-inner .ui-icon{position:absolute;left:50%;margin-left:-9px}.ui-btn-icon-left .ui-icon{left:10px}.ui-btn-icon-right .ui-icon{right:10px}.ui-btn-icon-top .ui-icon{top:10px}.ui-btn-icon-bottom .ui-icon{top:auto;bottom:10px}.ui-header .ui-btn-icon-left .ui-icon,.ui-footer .ui-btn-icon-left .ui-icon,.ui-mini.ui-btn-icon-left .ui-icon,.ui-mini .ui-btn-icon-left .ui-icon{left:5px}.ui-header .ui-btn-icon-right .ui-icon,.ui-footer .ui-btn-icon-right .ui-icon,.ui-mini.ui-btn-icon-right .ui-icon,.ui-mini .ui-btn-icon-right .ui-icon{right:5px}.ui-header .ui-btn-icon-top .ui-icon,.ui-footer .ui-btn-icon-top .ui-icon,.ui-mini.ui-btn-icon-top .ui-icon,.ui-mini .ui-btn-icon-top .ui-icon{top:5px}.ui-header .ui-btn-icon-bottom .ui-icon,.ui-footer .ui-btn-icon-bottom .ui-icon,.ui-mini.ui-btn-icon-bottom .ui-icon,.ui-mini .ui-btn-icon-bottom .ui-icon{bottom:5px}.ui-btn-hidden{position:absolute;top:0;left:0;width:100%;height:100%;-webkit-appearance:none;opacity:.1;cursor:pointer;background:#fff;background:rgba(255,255,255,0);filter:Alpha(Opacity=0);font-size:1px;border:0;text-indent:-9999px}.ui-field-contain .ui-btn.ui-submit{margin:0}label.ui-submit{font-size:16px;line-height:1.4;font-weight:normal;margin:0 0 .3em;display:block}@media all and (min-width:450px){.ui-field-contain label.ui-submit{vertical-align:top;display:inline-block;width:20%;margin:0 2% 0 0}.ui-field-contain .ui-btn.ui-submit{width:60%;display:inline-block;-webkit-box-sizing:border-box;-moz-box-sizing:border-box;-ms-box-sizing:border-box;box-sizing:border-box}.ui-hide-label .ui-btn.ui-submit{width:auto}}.ui-collapsible{margin:.5em 0}.ui-collapsible-heading{font-size:16px;display:block;margin:0 -8px;padding:0;border-width:0 0 1px 0;position:relative}.ui-collapsible-heading .ui-btn{text-align:left;margin:0}.ui-collapsible-heading .ui-btn-inner,.ui-collapsible-heading .ui-btn-icon-left .ui-btn-inner{padding-left:40px}.ui-collapsible-heading .ui-btn-icon-right .ui-btn-inner{padding-left:12px;padding-right:40px}.ui-collapsible-heading .ui-btn-icon-top .ui-btn-inner,.ui-collapsible-heading .ui-btn-icon-bottom .ui-btn-inner{padding-right:40px;text-align:center}.ui-collapsible-heading .ui-btn span.ui-btn{position:absolute;left:6px;top:50%;margin:-12px 0 0 0;width:20px;height:20px;padding:1px 0 1px 2px;text-indent:-9999px}.ui-collapsible-heading .ui-btn span.ui-btn .ui-btn-inner{padding:10px 0}.ui-collapsible-heading .ui-btn span.ui-btn .ui-icon{left:0;margin-top:-10px}.ui-collapsible-heading-status{position:absolute;top:-9999px;left:0}.ui-collapsible-content{display:block;margin:0 -8px;padding:10px 16px;border-top:0;background-image:none;font-weight:normal}.ui-collapsible-content-collapsed{display:none}.ui-collapsible-set{margin:.5em 0}.ui-collapsible-set .ui-collapsible{margin:-1px 0 0}.ui-controlgroup,fieldset.ui-controlgroup{padding:0;margin:.5em 0;zoom:1}.ui-controlgroup.ui-mini,fieldset.ui-controlgroup.ui-mini{margin:.25em 0}.ui-field-contain .ui-controlgroup,.ui-field-contain fieldset.ui-controlgroup{margin:0}.ui-bar .ui-controlgroup{margin:0 5px}.ui-controlgroup-label{font-size:16px;line-height:1.4;font-weight:normal;margin:0 0 .4em}.ui-controlgroup-controls{display:block;width:100%}.ui-controlgroup li{list-style:none}.ui-controlgroup-vertical .ui-btn,.ui-controlgroup-vertical .ui-checkbox,.ui-controlgroup-vertical .ui-radio{margin:0;border-bottom-width:0}.ui-controlgroup-vertical .ui-controlgroup-last{border-bottom-width:1px}.ui-controlgroup-controls label.ui-select{position:absolute;left:-9999px}.ui-controlgroup .ui-btn-icon-notext{width:24px;height:24px}.ui-controlgroup .ui-btn-icon-notext .ui-btn-inner .ui-icon{position:absolute;top:50%;right:50%;margin:-9px -9px 0 0}.ui-controlgroup-horizontal .ui-controlgroup-controls:before,.ui-controlgroup-horizontal .ui-controlgroup-controls:after{content:"";display:table}.ui-controlgroup-horizontal .ui-controlgroup-controls:after{clear:both}.ui-controlgroup-horizontal .ui-controlgroup-controls{zoom:1}.ui-controlgroup-horizontal .ui-btn-inner{text-align:center}.ui-controlgroup-horizontal .ui-btn,.ui-controlgroup-horizontal .ui-select,.ui-controlgroup-horizontal .ui-checkbox,.ui-controlgroup-horizontal .ui-radio{float:left;clear:none;margin:0 -1px 0 0}.ui-controlgroup-horizontal .ui-select .ui-btn,.ui-controlgroup-horizontal .ui-checkbox .ui-btn,.ui-controlgroup-horizontal .ui-radio .ui-btn,.ui-controlgroup-horizontal .ui-checkbox:last-child,.ui-controlgroup-horizontal .ui-radio:last-child{margin-right:0}.ui-controlgroup-horizontal .ui-controlgroup-last{margin-right:0}.ui-controlgroup .ui-checkbox label,.ui-controlgroup .ui-radio label{font-size:16px}@media all and (min-width:450px){.ui-field-contain .ui-controlgroup-label{vertical-align:top;display:inline-block;width:20%;margin:0 2% 0 0}.ui-field-contain .ui-controlgroup-controls{width:60%;display:inline-block}.ui-field-contain .ui-controlgroup .ui-select{width:100%;display:block}.ui-field-contain .ui-controlgroup-horizontal .ui-select{width:auto}.ui-hide-label .ui-controlgroup-controls{width:100%}}.ui-dialog{background:none!important}.ui-dialog-contain{width:92.5%;max-width:500px;margin:10% auto 15px auto;padding:0}.ui-dialog .ui-header{margin-top:15%;border:0;overflow:hidden}.ui-dialog .ui-header,.ui-dialog .ui-content,.ui-dialog .ui-footer{display:block;position:relative;width:auto}.ui-dialog .ui-header,.ui-dialog .ui-footer{z-index:10;padding:0}.ui-dialog .ui-footer{padding:0 15px}.ui-dialog .ui-content{padding:15px}.ui-dialog{margin-top:-15px}.ui-checkbox,.ui-radio{position:relative;clear:both;margin:0;z-index:1}.ui-checkbox .ui-btn,.ui-radio .ui-btn{margin:.5em 0;text-align:left;z-index:2}.ui-checkbox .ui-btn.ui-mini,.ui-radio .ui-btn.ui-mini{margin:.25em 0}.ui-controlgroup .ui-checkbox .ui-btn,.ui-controlgroup .ui-radio .ui-btn{margin:0}.ui-checkbox .ui-btn-inner,.ui-radio .ui-btn-inner{white-space:normal}.ui-checkbox .ui-btn-icon-left .ui-btn-inner,.ui-radio .ui-btn-icon-left .ui-btn-inner{padding-left:45px}.ui-checkbox .ui-mini.ui-btn-icon-left .ui-btn-inner,.ui-radio .ui-mini.ui-btn-icon-left .ui-btn-inner{padding-left:36px}.ui-checkbox .ui-btn-icon-right .ui-btn-inner,.ui-radio .ui-btn-icon-right .ui-btn-inner{padding-right:45px}.ui-checkbox .ui-mini.ui-btn-icon-right .ui-btn-inner,.ui-radio .ui-mini.ui-btn-icon-right .ui-btn-inner{padding-right:36px}.ui-checkbox .ui-btn-icon-top .ui-btn-inner,.ui-radio .ui-btn-icon-top .ui-btn-inner{padding-right:0;padding-left:0;text-align:center}.ui-checkbox .ui-btn-icon-bottom .ui-btn-inner,.ui-radio .ui-btn-icon-bottom .ui-btn-inner{padding-right:0;padding-left:0;text-align:center}.ui-checkbox .ui-icon,.ui-radio .ui-icon{top:1.1em}.ui-checkbox .ui-btn-icon-left .ui-icon,.ui-radio .ui-btn-icon-left .ui-icon{left:15px}.ui-checkbox .ui-mini.ui-btn-icon-left .ui-icon,.ui-radio .ui-mini.ui-btn-icon-left .ui-icon{left:9px}.ui-checkbox .ui-btn-icon-right .ui-icon,.ui-radio .ui-btn-icon-right .ui-icon{right:15px}.ui-checkbox .ui-mini.ui-btn-icon-right .ui-icon,.ui-radio .ui-mini.ui-btn-icon-right .ui-icon{right:9px}.ui-checkbox .ui-btn-icon-top .ui-icon,.ui-radio .ui-btn-icon-top .ui-icon{top:10px}.ui-checkbox .ui-btn-icon-bottom .ui-icon,.ui-radio .ui-btn-icon-bottom .ui-icon{top:auto;bottom:10px}.ui-checkbox .ui-btn-icon-right .ui-icon,.ui-radio .ui-btn-icon-right .ui-icon{right:15px}.ui-checkbox .ui-mini.ui-btn-icon-right .ui-icon,.ui-radio .ui-mini.ui-btn-icon-right .ui-icon{right:9px}.ui-checkbox input,.ui-radio input{position:absolute;left:20px;top:50%;width:10px;height:10px;margin:-5px 0 0 0;outline:0!important;z-index:1}.ui-field-contain,fieldset.ui-field-contain{padding:.8em 0;margin:0;border-width:0 0 1px 0;overflow:visible}.ui-field-contain:last-child{border-bottom-width:0}.ui-field-contain{max-width:100%}@media all and (min-width:450px){.ui-field-contain,.ui-mobile fieldset.ui-field-contain{border-width:0;padding:0;margin:1em 0}}.ui-select{display:block;position:relative}.ui-select select{position:absolute;left:-9999px;top:-9999px}.ui-select .ui-btn{overflow:hidden;opacity:1}.ui-field-contain .ui-select .ui-btn{margin:0}.ui-select .ui-btn select{cursor:pointer;-webkit-appearance:none;left:0;top:0;width:100%;min-height:1.5em;min-height:100%;height:3em;max-height:100%;opacity:0;-ms-filter:"alpha(opacity=0)";filter:alpha(opacity=0);z-index:2}.ui-select .ui-disabled{opacity:.3}@-moz-document url-prefix(){.ui-select .ui-btn select{opacity:.0001}}.ui-select .ui-btn.ui-select-nativeonly{border-radius:0}.ui-select .ui-btn.ui-select-nativeonly select{opacity:1;text-indent:0}.ui-select .ui-btn-icon-right .ui-btn-inner,.ui-select .ui-li-has-count .ui-btn-inner{padding-right:45px}.ui-select .ui-mini.ui-btn-icon-right .ui-btn-inner{padding-right:32px}.ui-select .ui-btn-icon-right.ui-li-has-count .ui-btn-inner{padding-right:80px}.ui-select .ui-mini.ui-btn-icon-right.ui-li-has-count .ui-btn-inner{padding-right:67px}.ui-select .ui-btn-icon-right .ui-icon{right:15px}.ui-select .ui-mini.ui-btn-icon-right .ui-icon{right:7px}.ui-select .ui-btn-icon-right.ui-li-has-count .ui-li-count{right:45px}.ui-select .ui-mini.ui-btn-icon-right.ui-li-has-count .ui-li-count{right:32px}label.ui-select{font-size:16px;line-height:1.4;font-weight:normal;margin:0 0 .3em;display:block}.ui-select .ui-btn-text,.ui-selectmenu .ui-btn-text{display:block;min-height:1em;overflow:hidden!important}.ui-select .ui-btn-text{text-overflow:ellipsis}.ui-selectmenu{position:absolute;padding:0;z-index:1100!important;width:80%;max-width:350px;padding:6px}.ui-selectmenu .ui-listview{margin:0}.ui-selectmenu .ui-btn.ui-li-divider{cursor:default}.ui-selectmenu-hidden{top:-99999px;left:-9999px}.ui-selectmenu-screen{position:absolute;top:0;left:0;width:100%;height:100%;z-index:99}.ui-screen-hidden,.ui-selectmenu-list .ui-li .ui-icon{display:none}.ui-selectmenu-list .ui-li .ui-icon{display:block}.ui-li.ui-selectmenu-placeholder{display:none}.ui-selectmenu .ui-header .ui-title{margin:.6em 46px .8em}@media all and (min-width:450px){.ui-field-contain label.ui-select{vertical-align:top;display:inline-block;width:20%;margin:0 2% 0 0}.ui-field-contain .ui-select{width:60%;display:inline-block}.ui-hide-label .ui-select{width:100%}}.ui-selectmenu .ui-header h1:after{content:'.';visibility:hidden}label.ui-input-text{font-size:16px;line-height:1.4;display:block;font-weight:normal;margin:0 0 .3em}input.ui-input-text,textarea.ui-input-text{background-image:none;padding:.4em;margin:.5em 0;line-height:1.4;font-size:16px;display:block;width:100%;outline:0}input.ui-input-text.ui-mini,textarea.ui-input-text.ui-mini{margin:.25em 0}.ui-field-contain input.ui-input-text,.ui-field-contain textarea.ui-input-text{margin:0}input.ui-input-text,textarea.ui-input-text,.ui-input-search{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;-ms-box-sizing:border-box;box-sizing:border-box}input.ui-input-text{-webkit-appearance:none}textarea.ui-input-text{height:50px;-webkit-transition:height 200ms linear;-moz-transition:height 200ms linear;-o-transition:height 200ms linear;transition:height 200ms linear}.ui-input-search{padding:0 30px;margin:.5em 0;background-image:none;position:relative}.ui-input-search.ui-mini{margin:.25em 0}.ui-field-contain .ui-input-search{margin:0}.ui-icon-searchfield:after{position:absolute;left:7px;top:50%;margin-top:-9px;content:"";width:18px;height:18px;opacity:.5}.ui-input-search input.ui-input-text{border:0;width:98%;padding:.4em 0;margin:0;display:block;background:transparent none;outline:0!important}.ui-input-search .ui-input-clear{position:absolute;right:0;top:50%;margin-top:-13px}.ui-mini .ui-input-clear{right:-3px}.ui-input-search .ui-input-clear-hidden{display:none}input.ui-mini,.ui-mini input,textarea.ui-mini{font-size:14px}textarea.ui-mini{height:45px}@media all and (min-width:450px){.ui-field-contain label.ui-input-text{vertical-align:top;display:inline-block;width:20%;margin:0 2% 0 0}.ui-field-contain input.ui-input-text,.ui-field-contain textarea.ui-input-text,.ui-field-contain .ui-input-search{width:60%;display:inline-block}.ui-hide-label input.ui-input-text,.ui-hide-label textarea.ui-input-text,.ui-hide-label .ui-input-search{width:100%}.ui-input-search input.ui-input-text{width:98%}}.ui-listview{margin:0;counter-reset:listnumbering}.ui-content .ui-listview{margin:-15px}.ui-content .ui-listview-inset{margin:1em 0}.ui-listview,.ui-li{list-style:none;padding:0}.ui-li,.ui-li.ui-field-contain{display:block;margin:0;position:relative;overflow:visible;text-align:left;border-width:0;border-top-width:1px}.ui-li .ui-btn-text a.ui-link-inherit{text-overflow:ellipsis;overflow:hidden;white-space:nowrap}.ui-li-divider,.ui-li-static{padding:.5em 15px;font-size:14px;font-weight:bold}.ui-li-divider .ui-btn-text,.ui-li-static .ui-btn-text{font-size:16px}.ui-li-divider .ui-mini .ui-btn-text,.ui-li-static .ui-mini .ui-btn-text{font-size:inherit}.ui-li-divider{counter-reset:listnumbering}ol.ui-listview .ui-link-inherit:before,ol.ui-listview .ui-li-static:before,.ui-li-dec{font-size:.8em;display:inline-block;padding-right:.3em;font-weight:normal;counter-increment:listnumbering;content:counter(listnumbering) ". "}ol.ui-listview .ui-li-jsnumbering:before{content:""!important}.ui-listview-inset .ui-li{border-right-width:1px;border-left-width:1px}.ui-li:last-child,.ui-li.ui-field-contain:last-child{border-bottom-width:1px}.ui-li>.ui-btn-inner{display:block;position:relative;padding:0}.ui-li .ui-btn-inner a.ui-link-inherit,.ui-li-static.ui-li{padding:.7em 15px;display:block}.ui-li-has-thumb .ui-btn-inner a.ui-link-inherit,.ui-li-static.ui-li-has-thumb{min-height:60px;padding-left:100px}.ui-li-has-icon .ui-btn-inner a.ui-link-inherit,.ui-li-static.ui-li-has-icon{min-height:20px;padding-left:40px}.ui-li-has-count .ui-btn-inner a.ui-link-inherit,.ui-li-static.ui-li-has-count,.ui-li-divider.ui-li-has-count{padding-right:45px}.ui-li-has-arrow .ui-btn-inner a.ui-link-inherit,.ui-li-static.ui-li-has-arrow{padding-right:40px}.ui-li-has-arrow.ui-li-has-count .ui-btn-inner a.ui-link-inherit,.ui-li-static.ui-li-has-arrow.ui-li-has-count{padding-right:75px}.ui-li-heading{font-size:16px;font-weight:bold;display:block;margin:.6em 0;text-overflow:ellipsis;overflow:hidden;white-space:nowrap}.ui-li-desc{font-size:12px;font-weight:normal;display:block;margin:-.5em 0 .6em;text-overflow:ellipsis;overflow:hidden;white-space:nowrap}.ui-li-thumb,.ui-listview .ui-li-icon{position:absolute;left:1px;top:0;max-height:80px;max-width:80px}.ui-listview .ui-li-icon{max-height:16px;max-width:16px;left:10px;top:.9em}.ui-li-thumb,.ui-listview .ui-li-icon,.ui-li-content{float:left;margin-right:10px}.ui-li-aside{float:right;width:50%;text-align:right;margin:.3em 0}@media all and (min-width:480px){.ui-li-aside{width:45%}}.ui-li-divider{cursor:default}.ui-li-has-alt .ui-btn-inner a.ui-link-inherit,.ui-li-static.ui-li-has-alt{padding-right:53px}.ui-li-has-alt.ui-li-has-count .ui-btn-inner a.ui-link-inherit,.ui-li-static.ui-li-has-alt.ui-li-has-count{padding-right:88px}.ui-li-has-count .ui-li-count{position:absolute;font-size:11px;font-weight:bold;padding:.2em .5em;top:50%;margin-top:-.9em;right:10px}.ui-li-has-count.ui-li-divider .ui-li-count,.ui-li-has-count .ui-link-inherit .ui-li-count{margin-top:-.95em}.ui-li-has-arrow.ui-li-has-count .ui-li-count{right:40px}.ui-li-has-alt.ui-li-has-count .ui-li-count{right:53px}.ui-li-link-alt{position:absolute;width:40px;height:100%;border-width:0;border-left-width:1px;top:0;right:0;margin:0;padding:0;z-index:2}.ui-li-link-alt .ui-btn{overflow:hidden;position:absolute;right:8px;top:50%;margin:-13px 0 0 0;border-bottom-width:1px;z-index:-1}.ui-li-link-alt .ui-btn-inner{padding:0;height:100%;position:absolute;width:100%;top:0;left:0}.ui-li-link-alt .ui-btn .ui-icon{right:50%;margin-right:-9px}.ui-li-link-alt .ui-btn-icon-notext .ui-btn-inner .ui-icon{position:absolute;top:50%;margin-top:-9px}.ui-listview * .ui-btn-inner>.ui-btn>.ui-btn-inner{border-top:0}.ui-listview-filter{border-width:0;overflow:hidden;margin:-15px -15px 15px -15px}.ui-listview-filter .ui-input-search{margin:5px;width:auto;display:block}.ui-listview-filter-inset{margin:-15px -5px -15px -5px;background:transparent}.ui-li.ui-screen-hidden{display:none}@media only screen and (min-device-width:768px) and (max-device-width:1024px){.ui-li .ui-btn-text{overflow:visible}}label.ui-slider{font-size:16px;line-height:1.4;font-weight:normal;margin:0 0 .3em;display:block}input.ui-slider-input,.ui-field-contain input.ui-slider-input{display:inline-block;width:50px;background-image:none;padding:.4em;margin:.5em 0;line-height:1.4;font-size:16px;outline:0}input.ui-slider-input.ui-mini,.ui-field-contain input.ui-slider-input.ui-mini{width:45px;margin:.25em 0;font-size:14px}.ui-field-contain input.ui-slider-input{margin:0}input.ui-slider-input,.ui-field-contain input.ui-slider-input{-webkit-box-sizing:content-box;-moz-box-sizing:content-box;-ms-box-sizing:content-box;box-sizing:content-box}select.ui-slider-switch{display:none}div.ui-slider{position:relative;display:inline-block;overflow:visible;height:15px;padding:0;margin:0 2% 0 20px;top:4px;width:65%}div.ui-slider-mini{height:12px;margin-left:10px;top:2px}div.ui-slider-bg{border:0;height:100%;padding-right:8px}.ui-controlgroup a.ui-slider-handle,a.ui-slider-handle{position:absolute;z-index:1;top:50%;width:28px;height:28px;margin-top:-15px;margin-left:-15px;outline:0}a.ui-slider-handle .ui-btn-inner{padding:0;height:100%}div.ui-slider-mini a.ui-slider-handle{height:14px;width:14px;margin:-8px 0 0 -7px}div.ui-slider-mini a.ui-slider-handle .ui-btn-inner{height:30px;width:30px;padding:0;margin:-9px 0 0 -9px;border-top:0}@media all and (min-width:450px){.ui-field-contain label.ui-slider{vertical-align:top;display:inline-block;width:20%;margin:0 2% 0 0}.ui-field-contain div.ui-slider{width:43%}.ui-field-contain div.ui-slider-switch{width:5.5em}}div.ui-slider-switch{height:32px;margin-left:0;width:5.8em}a.ui-slider-handle-snapping{-webkit-transition:left 70ms linear;-moz-transition:left 70ms linear}div.ui-slider-switch .ui-slider-handle{margin-top:1px}.ui-slider-inneroffset{margin:0 16px;position:relative;z-index:1}div.ui-slider-switch.ui-slider-mini{width:5em;height:29px}div.ui-slider-switch.ui-slider-mini .ui-slider-inneroffset{margin:0 15px 0 14px}div.ui-slider-switch.ui-slider-mini .ui-slider-handle{width:25px;height:25px;margin:1px 0 0 -13px}div.ui-slider-switch.ui-slider-mini a.ui-slider-handle .ui-btn-inner{height:30px;width:30px;padding:0;margin:0}span.ui-slider-label{position:absolute;text-align:center;width:100%;overflow:hidden;font-size:16px;top:0;line-height:2;min-height:100%;border-width:0;white-space:nowrap}.ui-slider-mini span.ui-slider-label{font-size:14px}span.ui-slider-label-a{z-index:1;left:0;text-indent:-1.5em}span.ui-slider-label-b{z-index:0;right:0;text-indent:1.5em}.ui-slider-inline{width:120px;display:inline-block}
\ No newline at end of file
diff --git a/module/web/static/css/mobile/my.css b/module/web/static/css/mobile/my.css
new file mode 100644
index 000000000..d00047e70
--- /dev/null
+++ b/module/web/static/css/mobile/my.css
@@ -0,0 +1,92 @@
+.text-align-center {
+  text-align: center;
+}
+.text-align-right {
+  text-align: right;
+}
+
+/** CSS for non-standard jQuery Mobile styles or Codiqa components **/
+.split-wrapper {
+  width: 100%;
+  min-height: 200px;
+  clear: both;
+}
+@media all and (min-width: 650px) {
+  .content-secondary {
+    text-align: left;
+    float: left;
+    width: 45%;
+    background: none;
+    padding: 1.5em 6% 3em 0;
+    margin: 0;
+  }
+  .content-secondary {
+    background: none;
+    border-top: none;
+  }
+  .content-primary {
+    width: 45%;
+    float: right;
+    margin-right: 1%;
+    padding-right: 1%;
+  }
+  .content-primary ul:first-child {
+    margin-top: 0;
+  }
+  .content-secondary ul.ui-listview, .content-secondary ul.ui-listview-inset {
+    margin: 0;
+  }
+  .content-secondary ul.ui-listview .ui-li-divider, .content-secondary ul.ui-listview .ui-li {
+    border-radius: 0px;
+  }
+  .content-secondary ul.ui-listview .ui-li {
+    border-left: 0;
+    border-right: 0;
+  }
+  .content-secondary h2 {
+    position: absolute;
+    left: -9999px;
+  }
+  .content-secondary .ui-li-divider {
+    padding-top: 1em;
+    padding-bottom: 1em;
+  }
+  .content-secondary {
+    margin: 0;
+    padding: 0;
+  }
+  
+}
+@media all and (min-width: 750px){
+  .content-secondary {
+    width: 34%;
+  }
+  .content-primary {
+    width: 60%;
+    padding-right: 1%;
+  }	
+}
+
+@media all and (min-width: 1200px){
+  .content-secondary {
+    width: 30%;
+    padding-right:6%;
+    margin: 0px 0 20px 5%;
+  }
+  .content-secondary ul {
+    margin: 0;
+  }
+  .content-secondary {
+    margin: 0;
+    padding: 0;
+  }
+  .content-primary {
+    width: 50%;
+    margin-right: 5%;
+    padding-right: 3%;
+  }
+  .content-primary {
+    width: 60%;
+  }
+}
+
diff --git a/module/web/static/css/mobile/style.css b/module/web/static/css/mobile/style.css
new file mode 100644
index 000000000..349b54bc0
--- /dev/null
+++ b/module/web/static/css/mobile/style.css
@@ -0,0 +1,214 @@
+

+/*

+    General

+ */

+

+* {

+    margin: 0;

+}

+

+html, body {

+    height: 100%;

+}

+

+body {

+    margin: 0;

+    padding: 0;

+    font-family: 'Abel', sans-serif;

+    font-size: 16px;

+    color: #757575;

+    background: url("../../img/default/fancy_deboss.png") repeat scroll 0 0 transparent;

+    min-width: 320px;

+}

+

+h1, h2, h3 {

+	margin: 0;

+	padding: 0;

+	font-weight: normal;

+	color: #221D1D;

+}

+

+h1 {

+	font-size: 2em;

+}

+

+h2 {

+	font-size: 2.4em;

+}

+

+h3 {

+	font-size: 1.6em;

+}

+

+p, ul, ol {

+	margin-top: 0;

+	line-height: 180%;

+}

+

+ul, ol {

+}

+

+a {

+	text-decoration: none;

+	color: #FF7637;

+}

+

+a:hover {

+}

+

+#wrap {

+    min-height: 100%;

+}

+

+#content {

+    padding-left: 10px;

+    padding-bottom: 30px; /* Height of footer */

+}

+

+#content:before {

+    display: block;

+    content: " ";

+    height: 30px;

+}

+

+/*

+    Header

+*/

+

+header {

+    background: url("../../img/default/main-wrapper-bg.png") repeat-x;

+    height: 30px;

+    position: fixed;

+    top: 0;

+    vertical-align: top;

+    width: 100%;

+    z-index: 10;

+    min-width: 1000px;

+    color: #ffffff;

+}

+

+header a {

+    color: #ffffff;

+}

+

+header:before {

+    position: absolute;

+    content: ' ';

+    top: 0;

+    right: 0;

+    bottom: 0;

+    left: 0;

+    background-color: transparent;

+    box-shadow: 0 0 5px black;

+    z-index: -1;

+}

+

+header div.center {

+    position: relative;

+    padding-left: 20px;

+    padding-right: 20px;

+}

+header span.title {

+    color: white;

+    float: left;

+    font-family: SansationRegular, sans-serif;

+    font-size: 18px;

+    cursor: default;

+    margin-top: 4px;

+    padding-left: 10px;

+}

+

+/*

+    Login

+*/

+.login {

+    vertical-align: middle;

+    text-align: center;

+    border: 2px solid #000000;

+    padding: 15px;

+	font-size: 17px;

+    border-radius: 15px;

+    -moz-border-radius: 15px;

+	-webkit-border-radius: 15px;

+}

+

+.login input, .login div{

+    padding: 3px;

+}

+.login_submit input {

+	padding: 5px 15px;

+}

+.login_user , .login_password  {

+	text-align: right;

+	width: 320px;

+	margin-left: auto;

+	margin-right: auto;

+}

+.login_user  span, .login_password span{

+	margin-right: 5px;

+}

+/*

+    Footer

+*/

+footer {

+    background: url("../../img/default/main-wrapper-bg.png") repeat-x;

+    height: 30px;

+    margin-top: -30px;

+    position: relative;

+    width: 100%;

+    z-index: 10;

+}

+

+footer .logo {

+    background: url(../../img/default/logo_grey.png) no-repeat;

+    float: left;

+    width: 60px;

+    height: 60px;

+    margin-top: 12px;

+    margin-right: 12px;

+}

+

+footer div.center {

+    padding-top: 10px;

+    width: 900px;

+    margin-left: auto;

+    margin-right: auto;

+}

+

+footer:before {

+    position: absolute;

+    content: ' ';

+    top: 0;

+    right: 0;

+    bottom: 0;

+    left: 0;

+    background-color: transparent;

+    box-shadow: 0 0 5px black;

+    z-index: -1;

+}

+

+footer .block {

+    font-size: 12px;

+    float: left;

+    margin: 0;

+    width: 150px;

+    padding-top: 6px;

+    padding-right: 30px;

+}

+

+footer .copyright {

+    text-align: center;

+    width: auto;

+    padding-top: 22px;

+}

+

+footer h2 {

+    background: url("../../img/default/double-line.gif") repeat-x scroll center bottom transparent !important;

+    color: #FFFFFF;

+    font-family: SansationLight, sans-serif;

+    font-size: 16px;

+    font-weight: normal;

+    line-height: 16px;

+    margin: 0;

+    padding-bottom: 6px;

+}
\ No newline at end of file
diff --git a/module/web/static/css/select2.css b/module/web/static/css/select2.css
new file mode 100644
index 000000000..1ff2abb1b
--- /dev/null
+++ b/module/web/static/css/select2.css
@@ -0,0 +1,603 @@
+/*
+Version: 3.3.1 Timestamp: Wed Feb 20 09:57:22 PST 2013
+*/
+.select2-container {
+    position: relative;
+    display: inline-block;
+    /* inline-block for ie7 */
+    zoom: 1;
+    *display: inline;
+    vertical-align: top;
+}
+
+.select2-container,
+.select2-drop,
+.select2-search,
+.select2-search input{
+  /*
+    Force border-box so that % widths fit the parent
+    container without overlap because of margin/padding.
+
+    More Info : http://www.quirksmode.org/css/box.html
+  */
+  -webkit-box-sizing: border-box; /* webkit */
+   -khtml-box-sizing: border-box; /* konqueror */
+     -moz-box-sizing: border-box; /* firefox */
+      -ms-box-sizing: border-box; /* ie */
+          box-sizing: border-box; /* css3 */
+}
+
+.select2-container .select2-choice {
+    display: block;
+    height: 26px;
+    padding: 0 0 0 8px;
+    overflow: hidden;
+    position: relative;
+
+    border: 1px solid #aaa;
+    white-space: nowrap;
+    line-height: 26px;
+    color: #444;
+    text-decoration: none;
+
+    -webkit-border-radius: 4px;
+       -moz-border-radius: 4px;
+            border-radius: 4px;
+
+    -webkit-background-clip: padding-box;
+       -moz-background-clip: padding;
+            background-clip: padding-box;
+
+    -webkit-touch-callout: none;
+      -webkit-user-select: none;
+       -khtml-user-select: none;
+         -moz-user-select: none;
+          -ms-user-select: none;
+              user-select: none;
+
+    background-color: #fff;
+    background-image: -webkit-gradient(linear, left bottom, left top, color-stop(0, #eeeeee), color-stop(0.5, white));
+    background-image: -webkit-linear-gradient(center bottom, #eeeeee 0%, white 50%);
+    background-image: -moz-linear-gradient(center bottom, #eeeeee 0%, white 50%);
+    background-image: -o-linear-gradient(bottom, #eeeeee 0%, #ffffff 50%);
+    background-image: -ms-linear-gradient(top, #ffffff 0%, #eeeeee 50%);
+    filter: progid:DXImageTransform.Microsoft.gradient(startColorstr = '#ffffff', endColorstr = '#eeeeee', GradientType = 0);
+    background-image: linear-gradient(top, #ffffff 0%, #eeeeee 50%);
+}
+
+.select2-container.select2-drop-above .select2-choice {
+    border-bottom-color: #aaa;
+
+    -webkit-border-radius:0 0 4px 4px;
+       -moz-border-radius:0 0 4px 4px;
+            border-radius:0 0 4px 4px;
+
+    background-image: -webkit-gradient(linear, left bottom, left top, color-stop(0, #eeeeee), color-stop(0.9, white));
+    background-image: -webkit-linear-gradient(center bottom, #eeeeee 0%, white 90%);
+    background-image: -moz-linear-gradient(center bottom, #eeeeee 0%, white 90%);
+    background-image: -o-linear-gradient(bottom, #eeeeee 0%, white 90%);
+    background-image: -ms-linear-gradient(top, #eeeeee 0%,#ffffff 90%);
+    filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#ffffff', endColorstr='#eeeeee',GradientType=0 );
+    background-image: linear-gradient(top, #eeeeee 0%,#ffffff 90%);
+}
+
+.select2-container .select2-choice span {
+    margin-right: 26px;
+    display: block;
+    overflow: hidden;
+
+    white-space: nowrap;
+
+    -ms-text-overflow: ellipsis;
+     -o-text-overflow: ellipsis;
+        text-overflow: ellipsis;
+}
+
+.select2-container .select2-choice abbr {
+    display: block;
+    width: 12px;
+    height: 12px;
+    position: absolute;
+    right: 26px;
+    top: 8px;
+
+    font-size: 1px;
+    text-decoration: none;
+
+    border: 0;
+    background: url('select2.png') right top no-repeat;
+    cursor: pointer;
+    outline: 0;
+}
+.select2-container .select2-choice abbr:hover {
+    background-position: right -11px;
+    cursor: pointer;
+}
+
+.select2-drop-mask {
+    position: absolute;
+    left: 0;
+    top: 0;
+    z-index: 9998;
+    opacity: 0;
+}
+
+.select2-drop {
+    width: 100%;
+    margin-top:-1px;
+    position: absolute;
+    z-index: 9999;
+    top: 100%;
+
+    background: #fff;
+    color: #000;
+    border: 1px solid #aaa;
+    border-top: 0;
+
+    -webkit-border-radius: 0 0 4px 4px;
+       -moz-border-radius: 0 0 4px 4px;
+            border-radius: 0 0 4px 4px;
+
+    -webkit-box-shadow: 0 4px 5px rgba(0, 0, 0, .15);
+       -moz-box-shadow: 0 4px 5px rgba(0, 0, 0, .15);
+            box-shadow: 0 4px 5px rgba(0, 0, 0, .15);
+}
+
+.select2-drop.select2-drop-above {
+    margin-top: 1px;
+    border-top: 1px solid #aaa;
+    border-bottom: 0;
+
+    -webkit-border-radius: 4px 4px 0 0;
+       -moz-border-radius: 4px 4px 0 0;
+            border-radius: 4px 4px 0 0;
+
+    -webkit-box-shadow: 0 -4px 5px rgba(0, 0, 0, .15);
+       -moz-box-shadow: 0 -4px 5px rgba(0, 0, 0, .15);
+            box-shadow: 0 -4px 5px rgba(0, 0, 0, .15);
+}
+
+.select2-container .select2-choice div {
+    display: block;
+    width: 18px;
+    height: 100%;
+    position: absolute;
+    right: 0;
+    top: 0;
+
+    border-left: 1px solid #aaa;
+    -webkit-border-radius: 0 4px 4px 0;
+       -moz-border-radius: 0 4px 4px 0;
+            border-radius: 0 4px 4px 0;
+
+    -webkit-background-clip: padding-box;
+       -moz-background-clip: padding;
+            background-clip: padding-box;
+
+    background: #ccc;
+    background-image: -webkit-gradient(linear, left bottom, left top, color-stop(0, #ccc), color-stop(0.6, #eee));
+    background-image: -webkit-linear-gradient(center bottom, #ccc 0%, #eee 60%);
+    background-image: -moz-linear-gradient(center bottom, #ccc 0%, #eee 60%);
+    background-image: -o-linear-gradient(bottom, #ccc 0%, #eee 60%);
+    background-image: -ms-linear-gradient(top, #cccccc 0%, #eeeeee 60%);
+    filter: progid:DXImageTransform.Microsoft.gradient(startColorstr = '#eeeeee', endColorstr = '#cccccc', GradientType = 0);
+    background-image: linear-gradient(top, #cccccc 0%, #eeeeee 60%);
+}
+
+.select2-container .select2-choice div b {
+    display: block;
+    width: 100%;
+    height: 100%;
+    background: url('select2.png') no-repeat 0 1px;
+}
+
+.select2-search {
+    display: inline-block;
+    width: 100%;
+    min-height: 26px;
+    margin: 0;
+    padding-left: 4px;
+    padding-right: 4px;
+
+    position: relative;
+    z-index: 10000;
+
+    white-space: nowrap;
+}
+
+.select2-search-hidden {
+    display: block;
+    position: absolute;
+    left: -10000px;
+}
+
+.select2-search input {
+    width: 100%;
+    height: auto !important;
+    min-height: 26px;
+    padding: 4px 20px 4px 5px;
+    margin: 0;
+
+    outline: 0;
+    font-family: sans-serif;
+    font-size: 1em;
+
+    border: 1px solid #aaa;
+    -webkit-border-radius: 0;
+       -moz-border-radius: 0;
+            border-radius: 0;
+
+    -webkit-box-shadow: none;
+       -moz-box-shadow: none;
+            box-shadow: none;
+
+    background: #fff url('select2.png') no-repeat 100% -22px;
+    background: url('select2.png') no-repeat 100% -22px, -webkit-gradient(linear, left bottom, left top, color-stop(0.85, white), color-stop(0.99, #eeeeee));
+    background: url('select2.png') no-repeat 100% -22px, -webkit-linear-gradient(center bottom, white 85%, #eeeeee 99%);
+    background: url('select2.png') no-repeat 100% -22px, -moz-linear-gradient(center bottom, white 85%, #eeeeee 99%);
+    background: url('select2.png') no-repeat 100% -22px, -o-linear-gradient(bottom, white 85%, #eeeeee 99%);
+    background: url('select2.png') no-repeat 100% -22px, -ms-linear-gradient(top, #ffffff 85%, #eeeeee 99%);
+    background: url('select2.png') no-repeat 100% -22px, linear-gradient(top, #ffffff 85%, #eeeeee 99%);
+}
+
+.select2-drop.select2-drop-above .select2-search input {
+    margin-top: 4px;
+}
+
+.select2-search input.select2-active {
+    background: #fff url('select2-spinner.gif') no-repeat 100%;
+    background: url('select2-spinner.gif') no-repeat 100%, -webkit-gradient(linear, left bottom, left top, color-stop(0.85, white), color-stop(0.99, #eeeeee));
+    background: url('select2-spinner.gif') no-repeat 100%, -webkit-linear-gradient(center bottom, white 85%, #eeeeee 99%);
+    background: url('select2-spinner.gif') no-repeat 100%, -moz-linear-gradient(center bottom, white 85%, #eeeeee 99%);
+    background: url('select2-spinner.gif') no-repeat 100%, -o-linear-gradient(bottom, white 85%, #eeeeee 99%);
+    background: url('select2-spinner.gif') no-repeat 100%, -ms-linear-gradient(top, #ffffff 85%, #eeeeee 99%);
+    background: url('select2-spinner.gif') no-repeat 100%, linear-gradient(top, #ffffff 85%, #eeeeee 99%);
+}
+
+.select2-container-active .select2-choice,
+.select2-container-active .select2-choices {
+    border: 1px solid #5897fb;
+    outline: none;
+
+    -webkit-box-shadow: 0 0 5px rgba(0,0,0,.3);
+       -moz-box-shadow: 0 0 5px rgba(0,0,0,.3);
+            box-shadow: 0 0 5px rgba(0,0,0,.3);
+}
+
+.select2-dropdown-open .select2-choice {
+    border-bottom-color: transparent;
+    -webkit-box-shadow: 0 1px 0 #fff inset;
+       -moz-box-shadow: 0 1px 0 #fff inset;
+            box-shadow: 0 1px 0 #fff inset;
+
+    -webkit-border-bottom-left-radius: 0;
+        -moz-border-radius-bottomleft: 0;
+            border-bottom-left-radius: 0;
+
+    -webkit-border-bottom-right-radius: 0;
+        -moz-border-radius-bottomright: 0;
+            border-bottom-right-radius: 0;
+
+    background-color: #eee;
+    background-image: -webkit-gradient(linear, left bottom, left top, color-stop(0, white), color-stop(0.5, #eeeeee));
+    background-image: -webkit-linear-gradient(center bottom, white 0%, #eeeeee 50%);
+    background-image: -moz-linear-gradient(center bottom, white 0%, #eeeeee 50%);
+    background-image: -o-linear-gradient(bottom, white 0%, #eeeeee 50%);
+    background-image: -ms-linear-gradient(top, #ffffff 0%,#eeeeee 50%);
+    filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#eeeeee', endColorstr='#ffffff',GradientType=0 );
+    background-image: linear-gradient(top, #ffffff 0%,#eeeeee 50%);
+}
+
+.select2-dropdown-open .select2-choice div {
+    background: transparent;
+    border-left: none;
+    filter: none;
+}
+.select2-dropdown-open .select2-choice div b {
+    background-position: -18px 1px;
+}
+
+/* results */
+.select2-results {
+    max-height: 200px;
+    padding: 0 0 0 4px;
+    margin: 4px 4px 4px 0;
+    position: relative;
+    overflow-x: hidden;
+    overflow-y: auto;
+    -webkit-tap-highlight-color: rgba(0,0,0,0);
+}
+
+.select2-results ul.select2-result-sub {
+    margin: 0;
+}
+
+.select2-results ul.select2-result-sub > li .select2-result-label { padding-left: 20px }
+.select2-results ul.select2-result-sub ul.select2-result-sub > li .select2-result-label { padding-left: 40px }
+.select2-results ul.select2-result-sub ul.select2-result-sub ul.select2-result-sub > li .select2-result-label { padding-left: 60px }
+.select2-results ul.select2-result-sub ul.select2-result-sub ul.select2-result-sub ul.select2-result-sub > li .select2-result-label { padding-left: 80px }
+.select2-results ul.select2-result-sub ul.select2-result-sub ul.select2-result-sub ul.select2-result-sub ul.select2-result-sub > li .select2-result-label { padding-left: 100px }
+.select2-results ul.select2-result-sub ul.select2-result-sub ul.select2-result-sub ul.select2-result-sub ul.select2-result-sub ul.select2-result-sub > li .select2-result-label { padding-left: 110px }
+.select2-results ul.select2-result-sub ul.select2-result-sub ul.select2-result-sub ul.select2-result-sub ul.select2-result-sub ul.select2-result-sub ul.select2-result-sub > li .select2-result-label { padding-left: 120px }
+
+.select2-results li {
+    list-style: none;
+    display: list-item;
+    background-image: none;
+}
+
+.select2-results li.select2-result-with-children > .select2-result-label {
+    font-weight: bold;
+}
+
+.select2-results .select2-result-label {
+    padding: 3px 7px 4px;
+    margin: 0;
+    cursor: pointer;
+
+    -webkit-touch-callout: none;
+      -webkit-user-select: none;
+       -khtml-user-select: none;
+         -moz-user-select: none;
+          -ms-user-select: none;
+              user-select: none;
+}
+
+.select2-results .select2-highlighted {
+    background: #3875d7;
+    color: #fff;
+}
+
+.select2-results li em {
+    background: #feffde;
+    font-style: normal;
+}
+
+.select2-results .select2-highlighted em {
+    background: transparent;
+}
+
+.select2-results .select2-highlighted ul {
+    background: white;
+    color: #000;
+}
+
+
+.select2-results .select2-no-results,
+.select2-results .select2-searching,
+.select2-results .select2-selection-limit {
+    background: #f4f4f4;
+    display: list-item;
+}
+
+/*
+disabled look for disabled choices in the results dropdown
+*/
+.select2-results .select2-disabled.select2-highlighted {
+    color: #666;
+    background: #f4f4f4;
+    display: list-item;
+    cursor: default;
+}
+.select2-results .select2-disabled {
+  background: #f4f4f4;
+  display: list-item;
+  cursor: default;
+}
+
+.select2-results .select2-selected {
+    display: none;
+}
+
+.select2-more-results.select2-active {
+    background: #f4f4f4 url('select2-spinner.gif') no-repeat 100%;
+}
+
+.select2-more-results {
+    background: #f4f4f4;
+    display: list-item;
+}
+
+/* disabled styles */
+
+.select2-container.select2-container-disabled .select2-choice {
+    background-color: #f4f4f4;
+    background-image: none;
+    border: 1px solid #ddd;
+    cursor: default;
+}
+
+.select2-container.select2-container-disabled .select2-choice div {
+    background-color: #f4f4f4;
+    background-image: none;
+    border-left: 0;
+}
+
+.select2-container.select2-container-disabled .select2-choice abbr {
+    display: none
+}
+
+
+/* multiselect */
+
+.select2-container-multi .select2-choices {
+    height: auto !important;
+    height: 1%;
+    margin: 0;
+    padding: 0;
+    position: relative;
+
+    border: 1px solid #aaa;
+    cursor: text;
+    overflow: hidden;
+
+    background-color: #fff;
+    background-image: -webkit-gradient(linear, 0% 0%, 0% 100%, color-stop(1%, #eeeeee), color-stop(15%, #ffffff));
+    background-image: -webkit-linear-gradient(top, #eeeeee 1%, #ffffff 15%);
+    background-image: -moz-linear-gradient(top, #eeeeee 1%, #ffffff 15%);
+    background-image: -o-linear-gradient(top, #eeeeee 1%, #ffffff 15%);
+    background-image: -ms-linear-gradient(top, #eeeeee 1%, #ffffff 15%);
+    background-image: linear-gradient(top, #eeeeee 1%, #ffffff 15%);
+}
+
+.select2-locked {
+  padding: 3px 5px 3px 5px !important;
+}
+
+.select2-container-multi .select2-choices {
+    min-height: 26px;
+}
+
+.select2-container-multi.select2-container-active .select2-choices {
+    border: 1px solid #5897fb;
+    outline: none;
+
+    -webkit-box-shadow: 0 0 5px rgba(0,0,0,.3);
+       -moz-box-shadow: 0 0 5px rgba(0,0,0,.3);
+            box-shadow: 0 0 5px rgba(0,0,0,.3);
+}
+.select2-container-multi .select2-choices li {
+    float: left;
+    list-style: none;
+}
+.select2-container-multi .select2-choices .select2-search-field {
+    margin: 0;
+    padding: 0;
+    white-space: nowrap;
+}
+
+.select2-container-multi .select2-choices .select2-search-field input {
+    padding: 5px;
+    margin: 1px 0;
+
+    font-family: sans-serif;
+    font-size: 100%;
+    color: #666;
+    outline: 0;
+    border: 0;
+    -webkit-box-shadow: none;
+       -moz-box-shadow: none;
+            box-shadow: none;
+    background: transparent !important;
+}
+
+.select2-container-multi .select2-choices .select2-search-field input.select2-active {
+    background: #fff url('select2-spinner.gif') no-repeat 100% !important;
+}
+
+.select2-default {
+    color: #999 !important;
+}
+
+.select2-container-multi .select2-choices .select2-search-choice {
+    padding: 3px 5px 3px 18px;
+    margin: 3px 0 3px 5px;
+    position: relative;
+
+    line-height: 13px;
+    color: #333;
+    cursor: default;
+    border: 1px solid #aaaaaa;
+
+    -webkit-border-radius: 3px;
+       -moz-border-radius: 3px;
+            border-radius: 3px;
+
+    -webkit-box-shadow: 0 0 2px #ffffff inset, 0 1px 0 rgba(0,0,0,0.05);
+       -moz-box-shadow: 0 0 2px #ffffff inset, 0 1px 0 rgba(0,0,0,0.05);
+            box-shadow: 0 0 2px #ffffff inset, 0 1px 0 rgba(0,0,0,0.05);
+
+    -webkit-background-clip: padding-box;
+       -moz-background-clip: padding;
+            background-clip: padding-box;
+
+    -webkit-touch-callout: none;
+      -webkit-user-select: none;
+       -khtml-user-select: none;
+         -moz-user-select: none;
+          -ms-user-select: none;
+              user-select: none;
+
+    background-color: #e4e4e4;
+    filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#eeeeee', endColorstr='#f4f4f4', GradientType=0 );
+    background-image: -webkit-gradient(linear, 0% 0%, 0% 100%, color-stop(20%, #f4f4f4), color-stop(50%, #f0f0f0), color-stop(52%, #e8e8e8), color-stop(100%, #eeeeee));
+    background-image: -webkit-linear-gradient(top, #f4f4f4 20%, #f0f0f0 50%, #e8e8e8 52%, #eeeeee 100%);
+    background-image: -moz-linear-gradient(top, #f4f4f4 20%, #f0f0f0 50%, #e8e8e8 52%, #eeeeee 100%);
+    background-image: -o-linear-gradient(top, #f4f4f4 20%, #f0f0f0 50%, #e8e8e8 52%, #eeeeee 100%);
+    background-image: -ms-linear-gradient(top, #f4f4f4 20%, #f0f0f0 50%, #e8e8e8 52%, #eeeeee 100%);
+    background-image: linear-gradient(top, #f4f4f4 20%, #f0f0f0 50%, #e8e8e8 52%, #eeeeee 100%);
+}
+.select2-container-multi .select2-choices .select2-search-choice span {
+    cursor: default;
+}
+.select2-container-multi .select2-choices .select2-search-choice-focus {
+    background: #d4d4d4;
+}
+
+.select2-search-choice-close {
+    display: block;
+    width: 12px;
+    height: 13px;
+    position: absolute;
+    right: 3px;
+    top: 4px;
+
+    font-size: 1px;
+    outline: none;
+    background: url('select2.png') right top no-repeat;
+}
+
+.select2-container-multi .select2-search-choice-close {
+    left: 3px;
+}
+
+.select2-container-multi .select2-choices .select2-search-choice .select2-search-choice-close:hover {
+  background-position: right -11px;
+}
+.select2-container-multi .select2-choices .select2-search-choice-focus .select2-search-choice-close {
+    background-position: right -11px;
+}
+
+/* disabled styles */
+.select2-container-multi.select2-container-disabled .select2-choices{
+    background-color: #f4f4f4;
+    background-image: none;
+    border: 1px solid #ddd;
+    cursor: default;
+}
+
+.select2-container-multi.select2-container-disabled .select2-choices .select2-search-choice {
+    padding: 3px 5px 3px 5px;
+    border: 1px solid #ddd;
+    background-image: none;
+    background-color: #f4f4f4;
+}
+
+.select2-container-multi.select2-container-disabled .select2-choices .select2-search-choice .select2-search-choice-close {
+    display: none;
+}
+/* end multiselect */
+
+
+.select2-result-selectable .select2-match,
+.select2-result-unselectable .select2-match {
+    text-decoration: underline;
+}
+
+.select2-offscreen {
+    position: absolute;
+    left: -10000px;
+}
+
+/* Retina-ize icons */
+
+@media only screen and (-webkit-min-device-pixel-ratio: 1.5), only screen and (min-resolution: 144dpi)  {
+  .select2-search input, .select2-search-choice-close, .select2-container .select2-choice abbr, .select2-container .select2-choice div b {
+      background-image: url('select2x2.png') !important;
+      background-repeat: no-repeat !important;
+      background-size: 60px 40px !important;
+  }
+  .select2-search input {
+      background-position: 100% -21px !important;
+  }
+}
diff --git a/module/web/static/fonts/Sansation_Bold-webfont.eot b/module/web/static/fonts/Sansation_Bold-webfont.eot
new file mode 100644
index 000000000..43ed2ee31
--- /dev/null
+++ b/module/web/static/fonts/Sansation_Bold-webfont.eot
diff --git a/module/web/static/fonts/Sansation_Bold-webfont.ttf b/module/web/static/fonts/Sansation_Bold-webfont.ttf
new file mode 100644
index 000000000..d2e7c4c2a
--- /dev/null
+++ b/module/web/static/fonts/Sansation_Bold-webfont.ttf
diff --git a/module/web/static/fonts/Sansation_Bold-webfont.woff b/module/web/static/fonts/Sansation_Bold-webfont.woff
new file mode 100644
index 000000000..9ee938d55
--- /dev/null
+++ b/module/web/static/fonts/Sansation_Bold-webfont.woff
diff --git a/module/web/static/fonts/Sansation_Light-webfont.eot b/module/web/static/fonts/Sansation_Light-webfont.eot
new file mode 100644
index 000000000..d83fa9cf6
--- /dev/null
+++ b/module/web/static/fonts/Sansation_Light-webfont.eot
diff --git a/module/web/static/fonts/Sansation_Light-webfont.ttf b/module/web/static/fonts/Sansation_Light-webfont.ttf
new file mode 100644
index 000000000..64d734bec
--- /dev/null
+++ b/module/web/static/fonts/Sansation_Light-webfont.ttf
diff --git a/module/web/static/fonts/Sansation_Light-webfont.woff b/module/web/static/fonts/Sansation_Light-webfont.woff
new file mode 100644
index 000000000..5f3dce493
--- /dev/null
+++ b/module/web/static/fonts/Sansation_Light-webfont.woff
diff --git a/module/web/static/fonts/Sansation_Regular-webfont.eot b/module/web/static/fonts/Sansation_Regular-webfont.eot
new file mode 100644
index 000000000..46219c9ff
--- /dev/null
+++ b/module/web/static/fonts/Sansation_Regular-webfont.eot
diff --git a/module/web/static/fonts/Sansation_Regular-webfont.ttf b/module/web/static/fonts/Sansation_Regular-webfont.ttf
new file mode 100644
index 000000000..92f686359
--- /dev/null
+++ b/module/web/static/fonts/Sansation_Regular-webfont.ttf
diff --git a/module/web/static/fonts/Sansation_Regular-webfont.woff b/module/web/static/fonts/Sansation_Regular-webfont.woff
new file mode 100644
index 000000000..524b67992
--- /dev/null
+++ b/module/web/static/fonts/Sansation_Regular-webfont.woff
diff --git a/module/web/static/fonts/fontawesome-webfont.eot b/module/web/static/fonts/fontawesome-webfont.eot
new file mode 100644
index 000000000..8924bad77
--- /dev/null
+++ b/module/web/static/fonts/fontawesome-webfont.eot
diff --git a/module/web/static/fonts/fontawesome-webfont.ttf b/module/web/static/fonts/fontawesome-webfont.ttf
new file mode 100644
index 000000000..0e8200b92
--- /dev/null
+++ b/module/web/static/fonts/fontawesome-webfont.ttf
diff --git a/module/web/static/fonts/fontawesome-webfont.woff b/module/web/static/fonts/fontawesome-webfont.woff
new file mode 100644
index 000000000..1b4d7bef4
--- /dev/null
+++ b/module/web/static/fonts/fontawesome-webfont.woff
diff --git a/module/web/static/fonts/fontawesome.txt b/module/web/static/fonts/fontawesome.txt
new file mode 100644
index 000000000..582283da0
--- /dev/null
+++ b/module/web/static/fonts/fontawesome.txt
@@ -0,0 +1,66 @@
+# List of icons needed for font-awesome
+# name, uni from http://icnfnt.com/
+music 001
+search 002
+user 007
+film 008
+file 016
+download-alt 019
+download 01a
+inbox 01c
+ok 00c
+remove 00d
+cog 013
+trash 014
+time 017
+repeat 01e
+refresh 021
+list-alt 022
+lock 023
+tag 02b
+tags 02c
+print 02f
+list 03a
+picture 03e
+pencil 040
+edit 044
+share 045
+check 046
+play 04b
+pause 04c
+stop 04d
+share-alt 064
+eye-open 06e
+eye-close 070
+bar-chart 080
+check-empty 096
+globe 0ac
+tasks 0ae
+filter 0b0
+plus-sign 055
+chevron-left 053
+chevron-right 054
+chevron-up 077
+chevron-down 078
+key 084
+cogs 085
+signout 08b
+signin 090
+hdd 0a0
+hand-left 0a5
+hand-down 0a7
+wrench 0ad
+inbox 01c
+share 045
+group 0c0
+cloud 0c2
+save 0c7
+carret-left 0d9
+sort-down 0dd
+sort-up 0de
+sitemap 0e8
+file-alt 0f6
+folder-open 07c
+folder-open-alt 115
+folder-close 07b
+folder-close-alt 114
\ No newline at end of file
diff --git a/module/web/static/img/default/bgpattern.png b/module/web/static/img/default/bgpattern.png
new file mode 100644
index 000000000..5111e6bdf
--- /dev/null
+++ b/module/web/static/img/default/bgpattern.png
diff --git a/module/web/static/img/default/bgpatterndark.png b/module/web/static/img/default/bgpatterndark.png
new file mode 100644
index 000000000..b6d7536d0
--- /dev/null
+++ b/module/web/static/img/default/bgpatterndark.png
diff --git a/module/web/static/img/default/box-separator.png b/module/web/static/img/default/box-separator.png
new file mode 100644
index 000000000..9860fd9e9
--- /dev/null
+++ b/module/web/static/img/default/box-separator.png
diff --git a/module/web/static/img/default/checks_sheet.png b/module/web/static/img/default/checks_sheet.png
new file mode 100644
index 000000000..9662b8070
--- /dev/null
+++ b/module/web/static/img/default/checks_sheet.png
diff --git a/module/web/static/img/default/double-line.gif b/module/web/static/img/default/double-line.gif
new file mode 100644
index 000000000..e9f4cf971
--- /dev/null
+++ b/module/web/static/img/default/double-line.gif
diff --git a/module/web/static/img/default/fancy_deboss.png b/module/web/static/img/default/fancy_deboss.png
new file mode 100644
index 000000000..926a762db
--- /dev/null
+++ b/module/web/static/img/default/fancy_deboss.png
diff --git a/module/web/static/img/default/logo.png b/module/web/static/img/default/logo.png
new file mode 100644
index 000000000..bb9c13679
--- /dev/null
+++ b/module/web/static/img/default/logo.png
diff --git a/module/web/static/img/default/logo_grey.png b/module/web/static/img/default/logo_grey.png
new file mode 100644
index 000000000..7061372aa
--- /dev/null
+++ b/module/web/static/img/default/logo_grey.png
diff --git a/module/web/static/img/favicon.ico b/module/web/static/img/favicon.ico
new file mode 100644
index 000000000..d7f9f1857
--- /dev/null
+++ b/module/web/static/img/favicon.ico
diff --git a/module/web/static/img/glyphicons-halflings-white.png b/module/web/static/img/glyphicons-halflings-white.png
new file mode 100755
index 000000000..3bf6484a2
--- /dev/null
+++ b/module/web/static/img/glyphicons-halflings-white.png
diff --git a/module/web/static/img/glyphicons-halflings.png b/module/web/static/img/glyphicons-halflings.png
new file mode 100755
index 000000000..a99699932
--- /dev/null
+++ b/module/web/static/img/glyphicons-halflings.png
diff --git a/module/web/static/img/icon.png b/module/web/static/img/icon.png
new file mode 100644
index 000000000..1ab4ca081
--- /dev/null
+++ b/module/web/static/img/icon.png
diff --git a/module/web/static/js/app.build.js b/module/web/static/js/app.build.js
new file mode 100644
index 000000000..c2a775981
--- /dev/null
+++ b/module/web/static/js/app.build.js
@@ -0,0 +1,22 @@
+//Install node.js, navigate to the js folder, and then run this command: "node r.js -o app.build.js"
+({
+
+  // Creates a js-optimized folder at the same folder level as your "js" folder and places the optimized project there
+  dir: "../js-optimized",
+
+  // Tells Require.js to look at desktop.js for all shim and path configurations
+  mainConfigFile: 'config.js',
+
+  // Modules to be optimized:
+  modules: [
+
+//    {
+//      name: "mobile"
+//    },
+
+    {
+      name: "default"
+    }
+  ]
+
+})
diff --git a/module/web/static/js/app.js b/module/web/static/js/app.js
new file mode 100644
index 000000000..53af4b797
--- /dev/null
+++ b/module/web/static/js/app.js
@@ -0,0 +1,56 @@
+/* 
+ *  Global Application Object
+ *  Contains all necessary logic shared across views
+ */
+/*jslint browser: true*/
+define([
+
+    // Libraries.
+    'jquery',
+    'underscore',
+    'backbone',
+    'utils/initHB',
+    'utils/animations',
+    'utils/lazyRequire',
+    'utils/dialogs',
+    'wreqr',
+    'bootstrap',
+    'animate'
+
+], function($, _, Backbone, Handlebars) {
+    'use strict';
+
+    var Application = function(options){
+        this.vent = new Backbone.Wreqr.EventAggregator();
+        _.extend(this, options);
+    };
+
+    // Add Global Helper functions
+    _.extend(Application.prototype, Backbone.Events, {
+
+        // Generates options dict that can be used for xhr requests
+        apiRequest: function(method, data, options) {
+            options || (options = {});
+            options.url = window.pathPrefix + "/api/" + method;
+            options.dataType = "json";
+            if (data) {
+                options.type = "POST";
+                options.data = {};
+                // Convert arguments to json
+                _.keys(data).map(function(key) {
+                    options.data[key] = JSON.stringify(data[key]);
+                });
+            }
+
+            return options;
+        },
+
+        openWebSocket: function(path) {
+            return new WebSocket(window.wsAddress.replace('%s', window.location.hostname) + path);
+        }
+    });
+
+
+    // Returns the app object to be available to other modules through require.js.
+    return new Application();
+});
\ No newline at end of file
diff --git a/module/web/static/js/collections/FileList.js b/module/web/static/js/collections/FileList.js
new file mode 100644
index 000000000..e91088867
--- /dev/null
+++ b/module/web/static/js/collections/FileList.js
@@ -0,0 +1,17 @@
+define(['jquery', 'backbone', 'underscore', 'models/File'], function($, Backbone, _, File) {
+
+    return Backbone.Collection.extend({
+
+        model: File,
+
+        comparator: function(file) {
+            return file.get('fileorder');
+        },
+
+        initialize: function() {
+
+        }
+
+    });
+
+});
\ No newline at end of file
diff --git a/module/web/static/js/collections/InteractionList.js b/module/web/static/js/collections/InteractionList.js
new file mode 100644
index 000000000..9ec175892
--- /dev/null
+++ b/module/web/static/js/collections/InteractionList.js
@@ -0,0 +1,48 @@
+define(['jquery', 'backbone', 'underscore', 'app', 'models/InteractionTask'],
+    function($, Backbone, _, App, InteractionTask) {
+
+        return Backbone.Collection.extend({
+
+            model: InteractionTask,
+
+            comparator: function(task) {
+                return task.get('iid');
+            },
+
+            fetch: function(options) {
+                options = App.apiRequest('getInteractionTasks/0', null, options);
+                var self = this;
+                options.success = function(data) {
+                    self.update(data);
+                };
+
+                return $.ajax(options);
+            },
+
+            toJSON: function() {
+                var data = {queries: 0, notifications: 0};
+
+                this.map(function(task) {
+                    if (task.isNotification())
+                        data.notifications++;
+                    else
+                        data.queries++;
+                });
+
+                return data;
+            },
+
+            // a task is waiting for attention (no notification)
+            hasTaskWaiting: function() {
+                var tasks = 0;
+                this.map(function(task) {
+                    if (!task.isNotification())
+                        tasks++;
+                });
+
+                return tasks > 0;
+            }
+
+        });
+
+    });
\ No newline at end of file
diff --git a/module/web/static/js/collections/PackageList.js b/module/web/static/js/collections/PackageList.js
new file mode 100644
index 000000000..a36f8bcdc
--- /dev/null
+++ b/module/web/static/js/collections/PackageList.js
@@ -0,0 +1,15 @@
+define(['jquery', 'backbone', 'underscore', 'models/Package'], function($, Backbone, _, Package) {
+
+    return Backbone.Collection.extend({
+
+        model: Package,
+
+        comparator: function(pack) {
+            return pack.get('packageorder');
+        },
+
+        initialize: function() {
+        }
+
+    });
+});
\ No newline at end of file
diff --git a/module/web/static/js/collections/ProgressList.js b/module/web/static/js/collections/ProgressList.js
new file mode 100644
index 000000000..1706d5f16
--- /dev/null
+++ b/module/web/static/js/collections/ProgressList.js
@@ -0,0 +1,17 @@
+define(['jquery', 'backbone', 'underscore', 'models/Progress'], function($, Backbone, _, Progress) {
+
+    return Backbone.Collection.extend({
+
+        model: Progress,
+
+        comparator: function(progress) {
+            return progress.get('eta');
+        },
+
+        initialize: function() {
+
+        }
+
+    });
+
+});
\ No newline at end of file
diff --git a/module/web/static/js/config.js b/module/web/static/js/config.js
new file mode 100644
index 000000000..474a77dc3
--- /dev/null
+++ b/module/web/static/js/config.js
@@ -0,0 +1,41 @@
+// Sets the require.js configuration for your application.
+require.config({
+
+    // XXX: To many dots in file breaks dependencies
+    paths: {
+
+        jquery: "libs/jquery-1.9.1",
+        jqueryui: "libs/jqueryui",
+        flot: "libs/jquery.flot-1.1",
+        transit: "libs/jquery.transit-0.9.9",
+        animate: "libs/jquery.animate-enhanced-0.99",
+        omniwindow: "libs/jquery.omniwindow",
+        select2: "libs/select2-3.3.1",
+        bootstrap: "libs/bootstrap-2.3",
+
+        underscore: "libs/lodash-1.0.1",
+        backbone: "libs/backbone-0.9.10",
+        wreqr: "libs/backbone.wreqr-0.1.0",
+        handlebars: "libs/Handlebars-1.0rc1",
+
+        // Plugins
+        text: "libs/text-2.0.3",
+        tpl: "../../templates"
+
+    },
+
+    // Sets the configuration for your third party scripts that are not AMD compatible
+    shim: {
+
+        "backbone": {
+            deps: ["underscore", "jquery"],
+            exports: "Backbone"  //attaches "Backbone" to the window object
+        },
+        "flot": ["jquery"],
+        "transit": ["jquery"],
+        "omniwindow": ["jquery"],
+        "select2": ["jquery"],
+        "bootstrap": ["jquery"],
+        "animate": ["jquery"]
+    } // end Shim Configuration
+});
\ No newline at end of file
diff --git a/module/web/static/js/default.js b/module/web/static/js/default.js
new file mode 100644
index 000000000..afe624ff9
--- /dev/null
+++ b/module/web/static/js/default.js
@@ -0,0 +1,24 @@
+define('default', ['require', 'jquery', 'app', 'views/headerView', 'views/dashboardView'],
+    function(require, $, App, HeaderView, DashboardView) {
+
+        App.init = function() {
+            App.header = new HeaderView();
+            App.header.render();
+        };
+
+        App.initDashboard = function() {
+            $(function() {
+                App.dashboard = new DashboardView();
+                App.dashboard.init();
+            });
+        };
+
+        App.initSettingsView = function() {
+            require(['views/settingsView'], function(SettingsView) {
+                App.settingsView = new SettingsView();
+                App.settingsView.render();
+            });
+        };
+
+        return App;
+    });
\ No newline at end of file
diff --git a/module/web/static/js/helpers/fileHelper.js b/module/web/static/js/helpers/fileHelper.js
new file mode 100644
index 000000000..085c222aa
--- /dev/null
+++ b/module/web/static/js/helpers/fileHelper.js
@@ -0,0 +1,54 @@
+// Helpers to render the file view
+define('helpers/fileHelper', ['handlebars', 'utils/apitypes', 'helpers/formatTime'],
+    function(Handlebars, Api, formatTime) {
+
+        function fileClass(file, options) {
+            if (file.finished)
+                return 'finished';
+            else if (file.failed)
+                return "failed";
+            else if (file.offline)
+                return "offline";
+            else if (file.online)
+                return "online";
+            else if (file.waiting)
+                return "waiting";
+            else if (file.downloading)
+                return "downloading";
+
+            return "";
+        }
+
+        // TODO
+        function fileIcon(media, options) {
+            return 'iconf-music';
+        }
+
+        // TODO rest of the states
+        function fileStatus(file, options) {
+            var s;
+            var msg = file.download.statusmsg;
+
+            if (file.failed) {
+                s = "<i class='iconf-remove'></i>&nbsp;";
+                if (file.download.error)
+                    s += file.download.error;
+                else s += msg;
+            } else if (file.finished)
+                s = "<i class='iconf-ok'></i>&nbsp;" + msg;
+            else if (file.downloading)
+                s = "<div class='progress'><div class='bar' style='width: " + file.progress + "%'>&nbsp;&nbsp;" +
+                    formatTime(file.eta) + "</div></div>";
+            else if (file.waiting)
+                s = "<i class='iconf-time'></i>&nbsp;" + formatTime(file.eta);
+            else
+                s = msg;
+
+            return new Handlebars.SafeString(s);
+        }
+
+        Handlebars.registerHelper('fileClass', fileClass);
+        Handlebars.registerHelper('fileIcon', fileIcon);
+        Handlebars.registerHelper('fileStatus', fileStatus);
+        return fileClass;
+    });
\ No newline at end of file
diff --git a/module/web/static/js/helpers/formatSize.js b/module/web/static/js/helpers/formatSize.js
new file mode 100644
index 000000000..a50588bc6
--- /dev/null
+++ b/module/web/static/js/helpers/formatSize.js
@@ -0,0 +1,13 @@
+// Format bytes in human readable format
+define('helpers/formatSize', ['handlebars'], function(Handlebars) {
+    var sizes = ["B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB"];
+    function formatSize(bytes, options) {
+        if (!bytes || bytes === 0) return '0 B';
+        var i = parseInt(Math.floor(Math.log(bytes) / Math.log(1024)));
+        // round to two digits
+        return (bytes / Math.pow(1024, i)).toFixed(2) + ' ' + sizes[i];
+    }
+
+    Handlebars.registerHelper('formatSize', formatSize);
+    return formatSize;
+});
\ No newline at end of file
diff --git a/module/web/static/js/helpers/formatTime.js b/module/web/static/js/helpers/formatTime.js
new file mode 100644
index 000000000..77d67a39c
--- /dev/null
+++ b/module/web/static/js/helpers/formatTime.js
@@ -0,0 +1,17 @@
+// Format bytes in human readable format
+define('helpers/formatTime', ['handlebars', 'utils/remaining'], function(Handlebars, Remaining) {
+
+
+    function formatTime(seconds, options) {
+        if (seconds === Infinity)
+            return '∞';
+        else if (!seconds || seconds <= 0)
+            return "-";
+
+        // TODO: digital or written string
+        return Remaining.getStringDigital(seconds, window.dates);
+    }
+
+    Handlebars.registerHelper('formatTime', formatTime);
+    return formatTime;
+});
\ No newline at end of file
diff --git a/module/web/static/js/libs/Handlebars-1.0rc1.js b/module/web/static/js/libs/Handlebars-1.0rc1.js
new file mode 100644
index 000000000..991242461
--- /dev/null
+++ b/module/web/static/js/libs/Handlebars-1.0rc1.js
@@ -0,0 +1,1927 @@
+// lib/handlebars/base.js
+(function () {
+/*jshint eqnull:true*/
+this.Handlebars = {};
+
+(function(Handlebars) {
+
+Handlebars.VERSION = "1.0.rc.1";
+
+Handlebars.helpers  = {};
+Handlebars.partials = {};
+
+Handlebars.registerHelper = function(name, fn, inverse) {
+  if(inverse) { fn.not = inverse; }
+  this.helpers[name] = fn;
+};
+
+Handlebars.registerPartial = function(name, str) {
+  this.partials[name] = str;
+};
+
+Handlebars.registerHelper('helperMissing', function(arg) {
+  if(arguments.length === 2) {
+    return undefined;
+  } else {
+    throw new Error("Could not find property '" + arg + "'");
+  }
+});
+
+var toString = Object.prototype.toString, functionType = "[object Function]";
+
+Handlebars.registerHelper('blockHelperMissing', function(context, options) {
+  var inverse = options.inverse || function() {}, fn = options.fn;
+
+
+  var ret = "";
+  var type = toString.call(context);
+
+  if(type === functionType) { context = context.call(this); }
+
+  if(context === true) {
+    return fn(this);
+  } else if(context === false || context == null) {
+    return inverse(this);
+  } else if(type === "[object Array]") {
+    if(context.length > 0) {
+      return Handlebars.helpers.each(context, options);
+    } else {
+      return inverse(this);
+    }
+  } else {
+    return fn(context);
+  }
+});
+
+Handlebars.K = function() {};
+
+Handlebars.createFrame = Object.create || function(object) {
+  Handlebars.K.prototype = object;
+  var obj = new Handlebars.K();
+  Handlebars.K.prototype = null;
+  return obj;
+};
+
+Handlebars.registerHelper('each', function(context, options) {
+  var fn = options.fn, inverse = options.inverse;
+  var ret = "", data;
+
+  if (options.data) {
+    data = Handlebars.createFrame(options.data);
+  }
+
+  if(context && context.length > 0) {
+    for(var i=0, j=context.length; i<j; i++) {
+      if (data) { data.index = i; }
+      ret = ret + fn(context[i], { data: data });
+    }
+  } else {
+    ret = inverse(this);
+  }
+  return ret;
+});
+
+Handlebars.registerHelper('if', function(context, options) {
+  var type = toString.call(context);
+  if(type === functionType) { context = context.call(this); }
+
+  if(!context || Handlebars.Utils.isEmpty(context)) {
+    return options.inverse(this);
+  } else {
+    return options.fn(this);
+  }
+});
+
+Handlebars.registerHelper('unless', function(context, options) {
+  var fn = options.fn, inverse = options.inverse;
+  options.fn = inverse;
+  options.inverse = fn;
+
+  return Handlebars.helpers['if'].call(this, context, options);
+});
+
+Handlebars.registerHelper('with', function(context, options) {
+  return options.fn(context);
+});
+
+Handlebars.registerHelper('log', function(context) {
+  Handlebars.log(context);
+});
+
+}(this.Handlebars));
+;
+// lib/handlebars/compiler/parser.js
+/* Jison generated parser */
+var handlebars = (function(){
+var parser = {trace: function trace() { },
+yy: {},
+symbols_: {"error":2,"root":3,"program":4,"EOF":5,"statements":6,"simpleInverse":7,"statement":8,"openInverse":9,"closeBlock":10,"openBlock":11,"mustache":12,"partial":13,"CONTENT":14,"COMMENT":15,"OPEN_BLOCK":16,"inMustache":17,"CLOSE":18,"OPEN_INVERSE":19,"OPEN_ENDBLOCK":20,"path":21,"OPEN":22,"OPEN_UNESCAPED":23,"OPEN_PARTIAL":24,"params":25,"hash":26,"DATA":27,"param":28,"STRING":29,"INTEGER":30,"BOOLEAN":31,"hashSegments":32,"hashSegment":33,"ID":34,"EQUALS":35,"pathSegments":36,"SEP":37,"$accept":0,"$end":1},
+terminals_: {2:"error",5:"EOF",14:"CONTENT",15:"COMMENT",16:"OPEN_BLOCK",18:"CLOSE",19:"OPEN_INVERSE",20:"OPEN_ENDBLOCK",22:"OPEN",23:"OPEN_UNESCAPED",24:"OPEN_PARTIAL",27:"DATA",29:"STRING",30:"INTEGER",31:"BOOLEAN",34:"ID",35:"EQUALS",37:"SEP"},
+productions_: [0,[3,2],[4,3],[4,1],[4,0],[6,1],[6,2],[8,3],[8,3],[8,1],[8,1],[8,1],[8,1],[11,3],[9,3],[10,3],[12,3],[12,3],[13,3],[13,4],[7,2],[17,3],[17,2],[17,2],[17,1],[17,1],[25,2],[25,1],[28,1],[28,1],[28,1],[28,1],[28,1],[26,1],[32,2],[32,1],[33,3],[33,3],[33,3],[33,3],[33,3],[21,1],[36,3],[36,1]],
+performAction: function anonymous(yytext,yyleng,yylineno,yy,yystate,$$,_$) {
+
+var $0 = $$.length - 1;
+switch (yystate) {
+case 1: return $$[$0-1]; 
+break;
+case 2: this.$ = new yy.ProgramNode($$[$0-2], $$[$0]); 
+break;
+case 3: this.$ = new yy.ProgramNode($$[$0]); 
+break;
+case 4: this.$ = new yy.ProgramNode([]); 
+break;
+case 5: this.$ = [$$[$0]]; 
+break;
+case 6: $$[$0-1].push($$[$0]); this.$ = $$[$0-1]; 
+break;
+case 7: this.$ = new yy.BlockNode($$[$0-2], $$[$0-1].inverse, $$[$0-1], $$[$0]); 
+break;
+case 8: this.$ = new yy.BlockNode($$[$0-2], $$[$0-1], $$[$0-1].inverse, $$[$0]); 
+break;
+case 9: this.$ = $$[$0]; 
+break;
+case 10: this.$ = $$[$0]; 
+break;
+case 11: this.$ = new yy.ContentNode($$[$0]); 
+break;
+case 12: this.$ = new yy.CommentNode($$[$0]); 
+break;
+case 13: this.$ = new yy.MustacheNode($$[$0-1][0], $$[$0-1][1]); 
+break;
+case 14: this.$ = new yy.MustacheNode($$[$0-1][0], $$[$0-1][1]); 
+break;
+case 15: this.$ = $$[$0-1]; 
+break;
+case 16: this.$ = new yy.MustacheNode($$[$0-1][0], $$[$0-1][1]); 
+break;
+case 17: this.$ = new yy.MustacheNode($$[$0-1][0], $$[$0-1][1], true); 
+break;
+case 18: this.$ = new yy.PartialNode($$[$0-1]); 
+break;
+case 19: this.$ = new yy.PartialNode($$[$0-2], $$[$0-1]); 
+break;
+case 20: 
+break;
+case 21: this.$ = [[$$[$0-2]].concat($$[$0-1]), $$[$0]]; 
+break;
+case 22: this.$ = [[$$[$0-1]].concat($$[$0]), null]; 
+break;
+case 23: this.$ = [[$$[$0-1]], $$[$0]]; 
+break;
+case 24: this.$ = [[$$[$0]], null]; 
+break;
+case 25: this.$ = [[new yy.DataNode($$[$0])], null]; 
+break;
+case 26: $$[$0-1].push($$[$0]); this.$ = $$[$0-1]; 
+break;
+case 27: this.$ = [$$[$0]]; 
+break;
+case 28: this.$ = $$[$0]; 
+break;
+case 29: this.$ = new yy.StringNode($$[$0]); 
+break;
+case 30: this.$ = new yy.IntegerNode($$[$0]); 
+break;
+case 31: this.$ = new yy.BooleanNode($$[$0]); 
+break;
+case 32: this.$ = new yy.DataNode($$[$0]); 
+break;
+case 33: this.$ = new yy.HashNode($$[$0]); 
+break;
+case 34: $$[$0-1].push($$[$0]); this.$ = $$[$0-1]; 
+break;
+case 35: this.$ = [$$[$0]]; 
+break;
+case 36: this.$ = [$$[$0-2], $$[$0]]; 
+break;
+case 37: this.$ = [$$[$0-2], new yy.StringNode($$[$0])]; 
+break;
+case 38: this.$ = [$$[$0-2], new yy.IntegerNode($$[$0])]; 
+break;
+case 39: this.$ = [$$[$0-2], new yy.BooleanNode($$[$0])]; 
+break;
+case 40: this.$ = [$$[$0-2], new yy.DataNode($$[$0])]; 
+break;
+case 41: this.$ = new yy.IdNode($$[$0]); 
+break;
+case 42: $$[$0-2].push($$[$0]); this.$ = $$[$0-2]; 
+break;
+case 43: this.$ = [$$[$0]]; 
+break;
+}
+},
+table: [{3:1,4:2,5:[2,4],6:3,8:4,9:5,11:6,12:7,13:8,14:[1,9],15:[1,10],16:[1,12],19:[1,11],22:[1,13],23:[1,14],24:[1,15]},{1:[3]},{5:[1,16]},{5:[2,3],7:17,8:18,9:5,11:6,12:7,13:8,14:[1,9],15:[1,10],16:[1,12],19:[1,19],20:[2,3],22:[1,13],23:[1,14],24:[1,15]},{5:[2,5],14:[2,5],15:[2,5],16:[2,5],19:[2,5],20:[2,5],22:[2,5],23:[2,5],24:[2,5]},{4:20,6:3,8:4,9:5,11:6,12:7,13:8,14:[1,9],15:[1,10],16:[1,12],19:[1,11],20:[2,4],22:[1,13],23:[1,14],24:[1,15]},{4:21,6:3,8:4,9:5,11:6,12:7,13:8,14:[1,9],15:[1,10],16:[1,12],19:[1,11],20:[2,4],22:[1,13],23:[1,14],24:[1,15]},{5:[2,9],14:[2,9],15:[2,9],16:[2,9],19:[2,9],20:[2,9],22:[2,9],23:[2,9],24:[2,9]},{5:[2,10],14:[2,10],15:[2,10],16:[2,10],19:[2,10],20:[2,10],22:[2,10],23:[2,10],24:[2,10]},{5:[2,11],14:[2,11],15:[2,11],16:[2,11],19:[2,11],20:[2,11],22:[2,11],23:[2,11],24:[2,11]},{5:[2,12],14:[2,12],15:[2,12],16:[2,12],19:[2,12],20:[2,12],22:[2,12],23:[2,12],24:[2,12]},{17:22,21:23,27:[1,24],34:[1,26],36:25},{17:27,21:23,27:[1,24],34:[1,26],36:25},{17:28,21:23,27:[1,24],34:[1,26],36:25},{17:29,21:23,27:[1,24],34:[1,26],36:25},{21:30,34:[1,26],36:25},{1:[2,1]},{6:31,8:4,9:5,11:6,12:7,13:8,14:[1,9],15:[1,10],16:[1,12],19:[1,11],22:[1,13],23:[1,14],24:[1,15]},{5:[2,6],14:[2,6],15:[2,6],16:[2,6],19:[2,6],20:[2,6],22:[2,6],23:[2,6],24:[2,6]},{17:22,18:[1,32],21:23,27:[1,24],34:[1,26],36:25},{10:33,20:[1,34]},{10:35,20:[1,34]},{18:[1,36]},{18:[2,24],21:41,25:37,26:38,27:[1,45],28:39,29:[1,42],30:[1,43],31:[1,44],32:40,33:46,34:[1,47],36:25},{18:[2,25]},{18:[2,41],27:[2,41],29:[2,41],30:[2,41],31:[2,41],34:[2,41],37:[1,48]},{18:[2,43],27:[2,43],29:[2,43],30:[2,43],31:[2,43],34:[2,43],37:[2,43]},{18:[1,49]},{18:[1,50]},{18:[1,51]},{18:[1,52],21:53,34:[1,26],36:25},{5:[2,2],8:18,9:5,11:6,12:7,13:8,14:[1,9],15:[1,10],16:[1,12],19:[1,11],20:[2,2],22:[1,13],23:[1,14],24:[1,15]},{14:[2,20],15:[2,20],16:[2,20],19:[2,20],22:[2,20],23:[2,20],24:[2,20]},{5:[2,7],14:[2,7],15:[2,7],16:[2,7],19:[2,7],20:[2,7],22:[2,7],23:[2,7],24:[2,7]},{21:54,34:[1,26],36:25},{5:[2,8],14:[2,8],15:[2,8],16:[2,8],19:[2,8],20:[2,8],22:[2,8],23:[2,8],24:[2,8]},{14:[2,14],15:[2,14],16:[2,14],19:[2,14],20:[2,14],22:[2,14],23:[2,14],24:[2,14]},{18:[2,22],21:41,26:55,27:[1,45],28:56,29:[1,42],30:[1,43],31:[1,44],32:40,33:46,34:[1,47],36:25},{18:[2,23]},{18:[2,27],27:[2,27],29:[2,27],30:[2,27],31:[2,27],34:[2,27]},{18:[2,33],33:57,34:[1,58]},{18:[2,28],27:[2,28],29:[2,28],30:[2,28],31:[2,28],34:[2,28]},{18:[2,29],27:[2,29],29:[2,29],30:[2,29],31:[2,29],34:[2,29]},{18:[2,30],27:[2,30],29:[2,30],30:[2,30],31:[2,30],34:[2,30]},{18:[2,31],27:[2,31],29:[2,31],30:[2,31],31:[2,31],34:[2,31]},{18:[2,32],27:[2,32],29:[2,32],30:[2,32],31:[2,32],34:[2,32]},{18:[2,35],34:[2,35]},{18:[2,43],27:[2,43],29:[2,43],30:[2,43],31:[2,43],34:[2,43],35:[1,59],37:[2,43]},{34:[1,60]},{14:[2,13],15:[2,13],16:[2,13],19:[2,13],20:[2,13],22:[2,13],23:[2,13],24:[2,13]},{5:[2,16],14:[2,16],15:[2,16],16:[2,16],19:[2,16],20:[2,16],22:[2,16],23:[2,16],24:[2,16]},{5:[2,17],14:[2,17],15:[2,17],16:[2,17],19:[2,17],20:[2,17],22:[2,17],23:[2,17],24:[2,17]},{5:[2,18],14:[2,18],15:[2,18],16:[2,18],19:[2,18],20:[2,18],22:[2,18],23:[2,18],24:[2,18]},{18:[1,61]},{18:[1,62]},{18:[2,21]},{18:[2,26],27:[2,26],29:[2,26],30:[2,26],31:[2,26],34:[2,26]},{18:[2,34],34:[2,34]},{35:[1,59]},{21:63,27:[1,67],29:[1,64],30:[1,65],31:[1,66],34:[1,26],36:25},{18:[2,42],27:[2,42],29:[2,42],30:[2,42],31:[2,42],34:[2,42],37:[2,42]},{5:[2,19],14:[2,19],15:[2,19],16:[2,19],19:[2,19],20:[2,19],22:[2,19],23:[2,19],24:[2,19]},{5:[2,15],14:[2,15],15:[2,15],16:[2,15],19:[2,15],20:[2,15],22:[2,15],23:[2,15],24:[2,15]},{18:[2,36],34:[2,36]},{18:[2,37],34:[2,37]},{18:[2,38],34:[2,38]},{18:[2,39],34:[2,39]},{18:[2,40],34:[2,40]}],
+defaultActions: {16:[2,1],24:[2,25],38:[2,23],55:[2,21]},
+parseError: function parseError(str, hash) {
+    throw new Error(str);
+},
+parse: function parse(input) {
+    var self = this, stack = [0], vstack = [null], lstack = [], table = this.table, yytext = "", yylineno = 0, yyleng = 0, recovering = 0, TERROR = 2, EOF = 1;
+    this.lexer.setInput(input);
+    this.lexer.yy = this.yy;
+    this.yy.lexer = this.lexer;
+    this.yy.parser = this;
+    if (typeof this.lexer.yylloc == "undefined")
+        this.lexer.yylloc = {};
+    var yyloc = this.lexer.yylloc;
+    lstack.push(yyloc);
+    var ranges = this.lexer.options && this.lexer.options.ranges;
+    if (typeof this.yy.parseError === "function")
+        this.parseError = this.yy.parseError;
+    function popStack(n) {
+        stack.length = stack.length - 2 * n;
+        vstack.length = vstack.length - n;
+        lstack.length = lstack.length - n;
+    }
+    function lex() {
+        var token;
+        token = self.lexer.lex() || 1;
+        if (typeof token !== "number") {
+            token = self.symbols_[token] || token;
+        }
+        return token;
+    }
+    var symbol, preErrorSymbol, state, action, a, r, yyval = {}, p, len, newState, expected;
+    while (true) {
+        state = stack[stack.length - 1];
+        if (this.defaultActions[state]) {
+            action = this.defaultActions[state];
+        } else {
+            if (symbol === null || typeof symbol == "undefined") {
+                symbol = lex();
+            }
+            action = table[state] && table[state][symbol];
+        }
+        if (typeof action === "undefined" || !action.length || !action[0]) {
+            var errStr = "";
+            if (!recovering) {
+                expected = [];
+                for (p in table[state])
+                    if (this.terminals_[p] && p > 2) {
+                        expected.push("'" + this.terminals_[p] + "'");
+                    }
+                if (this.lexer.showPosition) {
+                    errStr = "Parse error on line " + (yylineno + 1) + ":\n" + this.lexer.showPosition() + "\nExpecting " + expected.join(", ") + ", got '" + (this.terminals_[symbol] || symbol) + "'";
+                } else {
+                    errStr = "Parse error on line " + (yylineno + 1) + ": Unexpected " + (symbol == 1?"end of input":"'" + (this.terminals_[symbol] || symbol) + "'");
+                }
+                this.parseError(errStr, {text: this.lexer.match, token: this.terminals_[symbol] || symbol, line: this.lexer.yylineno, loc: yyloc, expected: expected});
+            }
+        }
+        if (action[0] instanceof Array && action.length > 1) {
+            throw new Error("Parse Error: multiple actions possible at state: " + state + ", token: " + symbol);
+        }
+        switch (action[0]) {
+        case 1:
+            stack.push(symbol);
+            vstack.push(this.lexer.yytext);
+            lstack.push(this.lexer.yylloc);
+            stack.push(action[1]);
+            symbol = null;
+            if (!preErrorSymbol) {
+                yyleng = this.lexer.yyleng;
+                yytext = this.lexer.yytext;
+                yylineno = this.lexer.yylineno;
+                yyloc = this.lexer.yylloc;
+                if (recovering > 0)
+                    recovering--;
+            } else {
+                symbol = preErrorSymbol;
+                preErrorSymbol = null;
+            }
+            break;
+        case 2:
+            len = this.productions_[action[1]][1];
+            yyval.$ = vstack[vstack.length - len];
+            yyval._$ = {first_line: lstack[lstack.length - (len || 1)].first_line, last_line: lstack[lstack.length - 1].last_line, first_column: lstack[lstack.length - (len || 1)].first_column, last_column: lstack[lstack.length - 1].last_column};
+            if (ranges) {
+                yyval._$.range = [lstack[lstack.length - (len || 1)].range[0], lstack[lstack.length - 1].range[1]];
+            }
+            r = this.performAction.call(yyval, yytext, yyleng, yylineno, this.yy, action[1], vstack, lstack);
+            if (typeof r !== "undefined") {
+                return r;
+            }
+            if (len) {
+                stack = stack.slice(0, -1 * len * 2);
+                vstack = vstack.slice(0, -1 * len);
+                lstack = lstack.slice(0, -1 * len);
+            }
+            stack.push(this.productions_[action[1]][0]);
+            vstack.push(yyval.$);
+            lstack.push(yyval._$);
+            newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
+            stack.push(newState);
+            break;
+        case 3:
+            return true;
+        }
+    }
+    return true;
+}
+};
+/* Jison generated lexer */
+var lexer = (function(){
+var lexer = ({EOF:1,
+parseError:function parseError(str, hash) {
+        if (this.yy.parser) {
+            this.yy.parser.parseError(str, hash);
+        } else {
+            throw new Error(str);
+        }
+    },
+setInput:function (input) {
+        this._input = input;
+        this._more = this._less = this.done = false;
+        this.yylineno = this.yyleng = 0;
+        this.yytext = this.matched = this.match = '';
+        this.conditionStack = ['INITIAL'];
+        this.yylloc = {first_line:1,first_column:0,last_line:1,last_column:0};
+        if (this.options.ranges) this.yylloc.range = [0,0];
+        this.offset = 0;
+        return this;
+    },
+input:function () {
+        var ch = this._input[0];
+        this.yytext += ch;
+        this.yyleng++;
+        this.offset++;
+        this.match += ch;
+        this.matched += ch;
+        var lines = ch.match(/(?:\r\n?|\n).*/g);
+        if (lines) {
+            this.yylineno++;
+            this.yylloc.last_line++;
+        } else {
+            this.yylloc.last_column++;
+        }
+        if (this.options.ranges) this.yylloc.range[1]++;
+
+        this._input = this._input.slice(1);
+        return ch;
+    },
+unput:function (ch) {
+        var len = ch.length;
+        var lines = ch.split(/(?:\r\n?|\n)/g);
+
+        this._input = ch + this._input;
+        this.yytext = this.yytext.substr(0, this.yytext.length-len-1);
+        //this.yyleng -= len;
+        this.offset -= len;
+        var oldLines = this.match.split(/(?:\r\n?|\n)/g);
+        this.match = this.match.substr(0, this.match.length-1);
+        this.matched = this.matched.substr(0, this.matched.length-1);
+
+        if (lines.length-1) this.yylineno -= lines.length-1;
+        var r = this.yylloc.range;
+
+        this.yylloc = {first_line: this.yylloc.first_line,
+          last_line: this.yylineno+1,
+          first_column: this.yylloc.first_column,
+          last_column: lines ?
+              (lines.length === oldLines.length ? this.yylloc.first_column : 0) + oldLines[oldLines.length - lines.length].length - lines[0].length:
+              this.yylloc.first_column - len
+          };
+
+        if (this.options.ranges) {
+            this.yylloc.range = [r[0], r[0] + this.yyleng - len];
+        }
+        return this;
+    },
+more:function () {
+        this._more = true;
+        return this;
+    },
+less:function (n) {
+        this.unput(this.match.slice(n));
+    },
+pastInput:function () {
+        var past = this.matched.substr(0, this.matched.length - this.match.length);
+        return (past.length > 20 ? '...':'') + past.substr(-20).replace(/\n/g, "");
+    },
+upcomingInput:function () {
+        var next = this.match;
+        if (next.length < 20) {
+            next += this._input.substr(0, 20-next.length);
+        }
+        return (next.substr(0,20)+(next.length > 20 ? '...':'')).replace(/\n/g, "");
+    },
+showPosition:function () {
+        var pre = this.pastInput();
+        var c = new Array(pre.length + 1).join("-");
+        return pre + this.upcomingInput() + "\n" + c+"^";
+    },
+next:function () {
+        if (this.done) {
+            return this.EOF;
+        }
+        if (!this._input) this.done = true;
+
+        var token,
+            match,
+            tempMatch,
+            index,
+            col,
+            lines;
+        if (!this._more) {
+            this.yytext = '';
+            this.match = '';
+        }
+        var rules = this._currentRules();
+        for (var i=0;i < rules.length; i++) {
+            tempMatch = this._input.match(this.rules[rules[i]]);
+            if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
+                match = tempMatch;
+                index = i;
+                if (!this.options.flex) break;
+            }
+        }
+        if (match) {
+            lines = match[0].match(/(?:\r\n?|\n).*/g);
+            if (lines) this.yylineno += lines.length;
+            this.yylloc = {first_line: this.yylloc.last_line,
+                           last_line: this.yylineno+1,
+                           first_column: this.yylloc.last_column,
+                           last_column: lines ? lines[lines.length-1].length-lines[lines.length-1].match(/\r?\n?/)[0].length : this.yylloc.last_column + match[0].length};
+            this.yytext += match[0];
+            this.match += match[0];
+            this.matches = match;
+            this.yyleng = this.yytext.length;
+            if (this.options.ranges) {
+                this.yylloc.range = [this.offset, this.offset += this.yyleng];
+            }
+            this._more = false;
+            this._input = this._input.slice(match[0].length);
+            this.matched += match[0];
+            token = this.performAction.call(this, this.yy, this, rules[index],this.conditionStack[this.conditionStack.length-1]);
+            if (this.done && this._input) this.done = false;
+            if (token) return token;
+            else return;
+        }
+        if (this._input === "") {
+            return this.EOF;
+        } else {
+            return this.parseError('Lexical error on line '+(this.yylineno+1)+'. Unrecognized text.\n'+this.showPosition(),
+                    {text: "", token: null, line: this.yylineno});
+        }
+    },
+lex:function lex() {
+        var r = this.next();
+        if (typeof r !== 'undefined') {
+            return r;
+        } else {
+            return this.lex();
+        }
+    },
+begin:function begin(condition) {
+        this.conditionStack.push(condition);
+    },
+popState:function popState() {
+        return this.conditionStack.pop();
+    },
+_currentRules:function _currentRules() {
+        return this.conditions[this.conditionStack[this.conditionStack.length-1]].rules;
+    },
+topState:function () {
+        return this.conditionStack[this.conditionStack.length-2];
+    },
+pushState:function begin(condition) {
+        this.begin(condition);
+    }});
+lexer.options = {};
+lexer.performAction = function anonymous(yy,yy_,$avoiding_name_collisions,YY_START) {
+
+var YYSTATE=YY_START
+switch($avoiding_name_collisions) {
+case 0:
+                                   if(yy_.yytext.slice(-1) !== "\\") this.begin("mu");
+                                   if(yy_.yytext.slice(-1) === "\\") yy_.yytext = yy_.yytext.substr(0,yy_.yyleng-1), this.begin("emu");
+                                   if(yy_.yytext) return 14;
+                                 
+break;
+case 1: return 14; 
+break;
+case 2:
+                                   if(yy_.yytext.slice(-1) !== "\\") this.popState();
+                                   if(yy_.yytext.slice(-1) === "\\") yy_.yytext = yy_.yytext.substr(0,yy_.yyleng-1);
+                                   return 14;
+                                 
+break;
+case 3: return 24; 
+break;
+case 4: return 16; 
+break;
+case 5: return 20; 
+break;
+case 6: return 19; 
+break;
+case 7: return 19; 
+break;
+case 8: return 23; 
+break;
+case 9: return 23; 
+break;
+case 10: yy_.yytext = yy_.yytext.substr(3,yy_.yyleng-5); this.popState(); return 15; 
+break;
+case 11: return 22; 
+break;
+case 12: return 35; 
+break;
+case 13: return 34; 
+break;
+case 14: return 34; 
+break;
+case 15: return 37; 
+break;
+case 16: /*ignore whitespace*/ 
+break;
+case 17: this.popState(); return 18; 
+break;
+case 18: this.popState(); return 18; 
+break;
+case 19: yy_.yytext = yy_.yytext.substr(1,yy_.yyleng-2).replace(/\\"/g,'"'); return 29; 
+break;
+case 20: yy_.yytext = yy_.yytext.substr(1,yy_.yyleng-2).replace(/\\"/g,'"'); return 29; 
+break;
+case 21: yy_.yytext = yy_.yytext.substr(1); return 27; 
+break;
+case 22: return 31; 
+break;
+case 23: return 31; 
+break;
+case 24: return 30; 
+break;
+case 25: return 34; 
+break;
+case 26: yy_.yytext = yy_.yytext.substr(1, yy_.yyleng-2); return 34; 
+break;
+case 27: return 'INVALID'; 
+break;
+case 28: return 5; 
+break;
+}
+};
+lexer.rules = [/^(?:[^\x00]*?(?=(\{\{)))/,/^(?:[^\x00]+)/,/^(?:[^\x00]{2,}?(?=(\{\{|$)))/,/^(?:\{\{>)/,/^(?:\{\{#)/,/^(?:\{\{\/)/,/^(?:\{\{\^)/,/^(?:\{\{\s*else\b)/,/^(?:\{\{\{)/,/^(?:\{\{&)/,/^(?:\{\{![\s\S]*?\}\})/,/^(?:\{\{)/,/^(?:=)/,/^(?:\.(?=[} ]))/,/^(?:\.\.)/,/^(?:[\/.])/,/^(?:\s+)/,/^(?:\}\}\})/,/^(?:\}\})/,/^(?:"(\\["]|[^"])*")/,/^(?:'(\\[']|[^'])*')/,/^(?:@[a-zA-Z]+)/,/^(?:true(?=[}\s]))/,/^(?:false(?=[}\s]))/,/^(?:[0-9]+(?=[}\s]))/,/^(?:[a-zA-Z0-9_$-]+(?=[=}\s\/.]))/,/^(?:\[[^\]]*\])/,/^(?:.)/,/^(?:$)/];
+lexer.conditions = {"mu":{"rules":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28],"inclusive":false},"emu":{"rules":[2],"inclusive":false},"INITIAL":{"rules":[0,1,28],"inclusive":true}};
+return lexer;})()
+parser.lexer = lexer;
+function Parser () { this.yy = {}; }Parser.prototype = parser;parser.Parser = Parser;
+return new Parser;
+})();
+if (typeof require !== 'undefined' && typeof exports !== 'undefined') {
+exports.parser = handlebars;
+exports.Parser = handlebars.Parser;
+exports.parse = function () { return handlebars.parse.apply(handlebars, arguments); }
+exports.main = function commonjsMain(args) {
+    if (!args[1])
+        throw new Error('Usage: '+args[0]+' FILE');
+    var source, cwd;
+    if (typeof process !== 'undefined') {
+        source = require('fs').readFileSync(require('path').resolve(args[1]), "utf8");
+    } else {
+        source = require("file").path(require("file").cwd()).join(args[1]).read({charset: "utf-8"});
+    }
+    return exports.parser.parse(source);
+}
+if (typeof module !== 'undefined' && require.main === module) {
+  exports.main(typeof process !== 'undefined' ? process.argv.slice(1) : require("system").args);
+}
+};
+;
+// lib/handlebars/compiler/base.js
+Handlebars.Parser = handlebars;
+
+Handlebars.parse = function(string) {
+  Handlebars.Parser.yy = Handlebars.AST;
+  return Handlebars.Parser.parse(string);
+};
+
+Handlebars.print = function(ast) {
+  return new Handlebars.PrintVisitor().accept(ast);
+};
+
+Handlebars.logger = {
+  DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3, level: 3,
+
+  // override in the host environment
+  log: function(level, str) {}
+};
+
+Handlebars.log = function(level, str) { Handlebars.logger.log(level, str); };
+;
+// lib/handlebars/compiler/ast.js
+(function() {
+
+  Handlebars.AST = {};
+
+  Handlebars.AST.ProgramNode = function(statements, inverse) {
+    this.type = "program";
+    this.statements = statements;
+    if(inverse) { this.inverse = new Handlebars.AST.ProgramNode(inverse); }
+  };
+
+  Handlebars.AST.MustacheNode = function(rawParams, hash, unescaped) {
+    this.type = "mustache";
+    this.escaped = !unescaped;
+    this.hash = hash;
+
+    var id = this.id = rawParams[0];
+    var params = this.params = rawParams.slice(1);
+
+    // a mustache is an eligible helper if:
+    // * its id is simple (a single part, not `this` or `..`)
+    var eligibleHelper = this.eligibleHelper = id.isSimple;
+
+    // a mustache is definitely a helper if:
+    // * it is an eligible helper, and
+    // * it has at least one parameter or hash segment
+    this.isHelper = eligibleHelper && (params.length || hash);
+
+    // if a mustache is an eligible helper but not a definite
+    // helper, it is ambiguous, and will be resolved in a later
+    // pass or at runtime.
+  };
+
+  Handlebars.AST.PartialNode = function(id, context) {
+    this.type    = "partial";
+
+    // TODO: disallow complex IDs
+
+    this.id      = id;
+    this.context = context;
+  };
+
+  var verifyMatch = function(open, close) {
+    if(open.original !== close.original) {
+      throw new Handlebars.Exception(open.original + " doesn't match " + close.original);
+    }
+  };
+
+  Handlebars.AST.BlockNode = function(mustache, program, inverse, close) {
+    verifyMatch(mustache.id, close);
+    this.type = "block";
+    this.mustache = mustache;
+    this.program  = program;
+    this.inverse  = inverse;
+
+    if (this.inverse && !this.program) {
+      this.isInverse = true;
+    }
+  };
+
+  Handlebars.AST.ContentNode = function(string) {
+    this.type = "content";
+    this.string = string;
+  };
+
+  Handlebars.AST.HashNode = function(pairs) {
+    this.type = "hash";
+    this.pairs = pairs;
+  };
+
+  Handlebars.AST.IdNode = function(parts) {
+    this.type = "ID";
+    this.original = parts.join(".");
+
+    var dig = [], depth = 0;
+
+    for(var i=0,l=parts.length; i<l; i++) {
+      var part = parts[i];
+
+      if(part === "..") { depth++; }
+      else if(part === "." || part === "this") { this.isScoped = true; }
+      else { dig.push(part); }
+    }
+
+    this.parts    = dig;
+    this.string   = dig.join('.');
+    this.depth    = depth;
+
+    // an ID is simple if it only has one part, and that part is not
+    // `..` or `this`.
+    this.isSimple = parts.length === 1 && !this.isScoped && depth === 0;
+  };
+
+  Handlebars.AST.DataNode = function(id) {
+    this.type = "DATA";
+    this.id = id;
+  };
+
+  Handlebars.AST.StringNode = function(string) {
+    this.type = "STRING";
+    this.string = string;
+  };
+
+  Handlebars.AST.IntegerNode = function(integer) {
+    this.type = "INTEGER";
+    this.integer = integer;
+  };
+
+  Handlebars.AST.BooleanNode = function(bool) {
+    this.type = "BOOLEAN";
+    this.bool = bool;
+  };
+
+  Handlebars.AST.CommentNode = function(comment) {
+    this.type = "comment";
+    this.comment = comment;
+  };
+
+})();;
+// lib/handlebars/utils.js
+Handlebars.Exception = function(message) {
+  var tmp = Error.prototype.constructor.apply(this, arguments);
+
+  for (var p in tmp) {
+    if (tmp.hasOwnProperty(p)) { this[p] = tmp[p]; }
+  }
+
+  this.message = tmp.message;
+};
+Handlebars.Exception.prototype = new Error();
+
+// Build out our basic SafeString type
+Handlebars.SafeString = function(string) {
+  this.string = string;
+};
+Handlebars.SafeString.prototype.toString = function() {
+  return this.string.toString();
+};
+
+(function() {
+  var escape = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#x27;",
+    "`": "&#x60;"
+  };
+
+  var badChars = /[&<>"'`]/g;
+  var possible = /[&<>"'`]/;
+
+  var escapeChar = function(chr) {
+    return escape[chr] || "&amp;";
+  };
+
+  Handlebars.Utils = {
+    escapeExpression: function(string) {
+      // don't escape SafeStrings, since they're already safe
+      if (string instanceof Handlebars.SafeString) {
+        return string.toString();
+      } else if (string == null || string === false) {
+        return "";
+      }
+
+      if(!possible.test(string)) { return string; }
+      return string.replace(badChars, escapeChar);
+    },
+
+    isEmpty: function(value) {
+      if (typeof value === "undefined") {
+        return true;
+      } else if (value === null) {
+        return true;
+      } else if (value === false) {
+        return true;
+      } else if(Object.prototype.toString.call(value) === "[object Array]" && value.length === 0) {
+        return true;
+      } else {
+        return false;
+      }
+    }
+  };
+})();;
+// lib/handlebars/compiler/compiler.js
+
+/*jshint eqnull:true*/
+Handlebars.Compiler = function() {};
+Handlebars.JavaScriptCompiler = function() {};
+
+(function(Compiler, JavaScriptCompiler) {
+  // the foundHelper register will disambiguate helper lookup from finding a
+  // function in a context. This is necessary for mustache compatibility, which
+  // requires that context functions in blocks are evaluated by blockHelperMissing,
+  // and then proceed as if the resulting value was provided to blockHelperMissing.
+
+  Compiler.prototype = {
+    compiler: Compiler,
+
+    disassemble: function() {
+      var opcodes = this.opcodes, opcode, out = [], params, param;
+
+      for (var i=0, l=opcodes.length; i<l; i++) {
+        opcode = opcodes[i];
+
+        if (opcode.opcode === 'DECLARE') {
+          out.push("DECLARE " + opcode.name + "=" + opcode.value);
+        } else {
+          params = [];
+          for (var j=0; j<opcode.args.length; j++) {
+            param = opcode.args[j];
+            if (typeof param === "string") {
+              param = "\"" + param.replace("\n", "\\n") + "\"";
+            }
+            params.push(param);
+          }
+          out.push(opcode.opcode + " " + params.join(" "));
+        }
+      }
+
+      return out.join("\n");
+    },
+
+    guid: 0,
+
+    compile: function(program, options) {
+      this.children = [];
+      this.depths = {list: []};
+      this.options = options;
+
+      // These changes will propagate to the other compiler components
+      var knownHelpers = this.options.knownHelpers;
+      this.options.knownHelpers = {
+        'helperMissing': true,
+        'blockHelperMissing': true,
+        'each': true,
+        'if': true,
+        'unless': true,
+        'with': true,
+        'log': true
+      };
+      if (knownHelpers) {
+        for (var name in knownHelpers) {
+          this.options.knownHelpers[name] = knownHelpers[name];
+        }
+      }
+
+      return this.program(program);
+    },
+
+    accept: function(node) {
+      return this[node.type](node);
+    },
+
+    program: function(program) {
+      var statements = program.statements, statement;
+      this.opcodes = [];
+
+      for(var i=0, l=statements.length; i<l; i++) {
+        statement = statements[i];
+        this[statement.type](statement);
+      }
+      this.isSimple = l === 1;
+
+      this.depths.list = this.depths.list.sort(function(a, b) {
+        return a - b;
+      });
+
+      return this;
+    },
+
+    compileProgram: function(program) {
+      var result = new this.compiler().compile(program, this.options);
+      var guid = this.guid++, depth;
+
+      this.usePartial = this.usePartial || result.usePartial;
+
+      this.children[guid] = result;
+
+      for(var i=0, l=result.depths.list.length; i<l; i++) {
+        depth = result.depths.list[i];
+
+        if(depth < 2) { continue; }
+        else { this.addDepth(depth - 1); }
+      }
+
+      return guid;
+    },
+
+    block: function(block) {
+      var mustache = block.mustache,
+          program = block.program,
+          inverse = block.inverse;
+
+      if (program) {
+        program = this.compileProgram(program);
+      }
+
+      if (inverse) {
+        inverse = this.compileProgram(inverse);
+      }
+
+      var type = this.classifyMustache(mustache);
+
+      if (type === "helper") {
+        this.helperMustache(mustache, program, inverse);
+      } else if (type === "simple") {
+        this.simpleMustache(mustache);
+
+        // now that the simple mustache is resolved, we need to
+        // evaluate it by executing `blockHelperMissing`
+        this.opcode('pushProgram', program);
+        this.opcode('pushProgram', inverse);
+        this.opcode('pushLiteral', '{}');
+        this.opcode('blockValue');
+      } else {
+        this.ambiguousMustache(mustache, program, inverse);
+
+        // now that the simple mustache is resolved, we need to
+        // evaluate it by executing `blockHelperMissing`
+        this.opcode('pushProgram', program);
+        this.opcode('pushProgram', inverse);
+        this.opcode('pushLiteral', '{}');
+        this.opcode('ambiguousBlockValue');
+      }
+
+      this.opcode('append');
+    },
+
+    hash: function(hash) {
+      var pairs = hash.pairs, pair, val;
+
+      this.opcode('push', '{}');
+
+      for(var i=0, l=pairs.length; i<l; i++) {
+        pair = pairs[i];
+        val  = pair[1];
+
+        this.accept(val);
+        this.opcode('assignToHash', pair[0]);
+      }
+    },
+
+    partial: function(partial) {
+      var id = partial.id;
+      this.usePartial = true;
+
+      if(partial.context) {
+        this.ID(partial.context);
+      } else {
+        this.opcode('push', 'depth0');
+      }
+
+      this.opcode('invokePartial', id.original);
+      this.opcode('append');
+    },
+
+    content: function(content) {
+      this.opcode('appendContent', content.string);
+    },
+
+    mustache: function(mustache) {
+      var options = this.options;
+      var type = this.classifyMustache(mustache);
+
+      if (type === "simple") {
+        this.simpleMustache(mustache);
+      } else if (type === "helper") {
+        this.helperMustache(mustache);
+      } else {
+        this.ambiguousMustache(mustache);
+      }
+
+      if(mustache.escaped && !options.noEscape) {
+        this.opcode('appendEscaped');
+      } else {
+        this.opcode('append');
+      }
+    },
+
+    ambiguousMustache: function(mustache, program, inverse) {
+      var id = mustache.id, name = id.parts[0];
+
+      this.opcode('getContext', id.depth);
+
+      this.opcode('pushProgram', program);
+      this.opcode('pushProgram', inverse);
+
+      this.opcode('invokeAmbiguous', name);
+    },
+
+    simpleMustache: function(mustache, program, inverse) {
+      var id = mustache.id;
+
+      if (id.type === 'DATA') {
+        this.DATA(id);
+      } else if (id.parts.length) {
+        this.ID(id);
+      } else {
+        // Simplified ID for `this`
+        this.addDepth(id.depth);
+        this.opcode('getContext', id.depth);
+        this.opcode('pushContext');
+      }
+
+      this.opcode('resolvePossibleLambda');
+    },
+
+    helperMustache: function(mustache, program, inverse) {
+      var params = this.setupFullMustacheParams(mustache, program, inverse),
+          name = mustache.id.parts[0];
+
+      if (this.options.knownHelpers[name]) {
+        this.opcode('invokeKnownHelper', params.length, name);
+      } else if (this.knownHelpersOnly) {
+        throw new Error("You specified knownHelpersOnly, but used the unknown helper " + name);
+      } else {
+        this.opcode('invokeHelper', params.length, name);
+      }
+    },
+
+    ID: function(id) {
+      this.addDepth(id.depth);
+      this.opcode('getContext', id.depth);
+
+      var name = id.parts[0];
+      if (!name) {
+        this.opcode('pushContext');
+      } else {
+        this.opcode('lookupOnContext', id.parts[0]);
+      }
+
+      for(var i=1, l=id.parts.length; i<l; i++) {
+        this.opcode('lookup', id.parts[i]);
+      }
+    },
+
+    DATA: function(data) {
+      this.options.data = true;
+      this.opcode('lookupData', data.id);
+    },
+
+    STRING: function(string) {
+      this.opcode('pushString', string.string);
+    },
+
+    INTEGER: function(integer) {
+      this.opcode('pushLiteral', integer.integer);
+    },
+
+    BOOLEAN: function(bool) {
+      this.opcode('pushLiteral', bool.bool);
+    },
+
+    comment: function() {},
+
+    // HELPERS
+    opcode: function(name) {
+      this.opcodes.push({ opcode: name, args: [].slice.call(arguments, 1) });
+    },
+
+    declare: function(name, value) {
+      this.opcodes.push({ opcode: 'DECLARE', name: name, value: value });
+    },
+
+    addDepth: function(depth) {
+      if(isNaN(depth)) { throw new Error("EWOT"); }
+      if(depth === 0) { return; }
+
+      if(!this.depths[depth]) {
+        this.depths[depth] = true;
+        this.depths.list.push(depth);
+      }
+    },
+
+    classifyMustache: function(mustache) {
+      var isHelper   = mustache.isHelper;
+      var isEligible = mustache.eligibleHelper;
+      var options    = this.options;
+
+      // if ambiguous, we can possibly resolve the ambiguity now
+      if (isEligible && !isHelper) {
+        var name = mustache.id.parts[0];
+
+        if (options.knownHelpers[name]) {
+          isHelper = true;
+        } else if (options.knownHelpersOnly) {
+          isEligible = false;
+        }
+      }
+
+      if (isHelper) { return "helper"; }
+      else if (isEligible) { return "ambiguous"; }
+      else { return "simple"; }
+    },
+
+    pushParams: function(params) {
+      var i = params.length, param;
+
+      while(i--) {
+        param = params[i];
+
+        if(this.options.stringParams) {
+          if(param.depth) {
+            this.addDepth(param.depth);
+          }
+
+          this.opcode('getContext', param.depth || 0);
+          this.opcode('pushStringParam', param.string);
+        } else {
+          this[param.type](param);
+        }
+      }
+    },
+
+    setupMustacheParams: function(mustache) {
+      var params = mustache.params;
+      this.pushParams(params);
+
+      if(mustache.hash) {
+        this.hash(mustache.hash);
+      } else {
+        this.opcode('pushLiteral', '{}');
+      }
+
+      return params;
+    },
+
+    // this will replace setupMustacheParams when we're done
+    setupFullMustacheParams: function(mustache, program, inverse) {
+      var params = mustache.params;
+      this.pushParams(params);
+
+      this.opcode('pushProgram', program);
+      this.opcode('pushProgram', inverse);
+
+      if(mustache.hash) {
+        this.hash(mustache.hash);
+      } else {
+        this.opcode('pushLiteral', '{}');
+      }
+
+      return params;
+    }
+  };
+
+  var Literal = function(value) {
+    this.value = value;
+  };
+
+  JavaScriptCompiler.prototype = {
+    // PUBLIC API: You can override these methods in a subclass to provide
+    // alternative compiled forms for name lookup and buffering semantics
+    nameLookup: function(parent, name, type) {
+      if (/^[0-9]+$/.test(name)) {
+        return parent + "[" + name + "]";
+      } else if (JavaScriptCompiler.isValidJavaScriptVariableName(name)) {
+        return parent + "." + name;
+      }
+      else {
+        return parent + "['" + name + "']";
+      }
+    },
+
+    appendToBuffer: function(string) {
+      if (this.environment.isSimple) {
+        return "return " + string + ";";
+      } else {
+        return "buffer += " + string + ";";
+      }
+    },
+
+    initializeBuffer: function() {
+      return this.quotedString("");
+    },
+
+    namespace: "Handlebars",
+    // END PUBLIC API
+
+    compile: function(environment, options, context, asObject) {
+      this.environment = environment;
+      this.options = options || {};
+
+      Handlebars.log(Handlebars.logger.DEBUG, this.environment.disassemble() + "\n\n");
+
+      this.name = this.environment.name;
+      this.isChild = !!context;
+      this.context = context || {
+        programs: [],
+        aliases: { }
+      };
+
+      this.preamble();
+
+      this.stackSlot = 0;
+      this.stackVars = [];
+      this.registers = { list: [] };
+      this.compileStack = [];
+
+      this.compileChildren(environment, options);
+
+      var opcodes = environment.opcodes, opcode;
+
+      this.i = 0;
+
+      for(l=opcodes.length; this.i<l; this.i++) {
+        opcode = opcodes[this.i];
+
+        if(opcode.opcode === 'DECLARE') {
+          this[opcode.name] = opcode.value;
+        } else {
+          this[opcode.opcode].apply(this, opcode.args);
+        }
+      }
+
+      return this.createFunctionContext(asObject);
+    },
+
+    nextOpcode: function() {
+      var opcodes = this.environment.opcodes, opcode = opcodes[this.i + 1];
+      return opcodes[this.i + 1];
+    },
+
+    eat: function(opcode) {
+      this.i = this.i + 1;
+    },
+
+    preamble: function() {
+      var out = [];
+
+      if (!this.isChild) {
+        var namespace = this.namespace;
+        var copies = "helpers = helpers || " + namespace + ".helpers;";
+        if (this.environment.usePartial) { copies = copies + " partials = partials || " + namespace + ".partials;"; }
+        if (this.options.data) { copies = copies + " data = data || {};"; }
+        out.push(copies);
+      } else {
+        out.push('');
+      }
+
+      if (!this.environment.isSimple) {
+        out.push(", buffer = " + this.initializeBuffer());
+      } else {
+        out.push("");
+      }
+
+      // track the last context pushed into place to allow skipping the
+      // getContext opcode when it would be a noop
+      this.lastContext = 0;
+      this.source = out;
+    },
+
+    createFunctionContext: function(asObject) {
+      var locals = this.stackVars.concat(this.registers.list);
+
+      if(locals.length > 0) {
+        this.source[1] = this.source[1] + ", " + locals.join(", ");
+      }
+
+      // Generate minimizer alias mappings
+      if (!this.isChild) {
+        var aliases = [];
+        for (var alias in this.context.aliases) {
+          this.source[1] = this.source[1] + ', ' + alias + '=' + this.context.aliases[alias];
+        }
+      }
+
+      if (this.source[1]) {
+        this.source[1] = "var " + this.source[1].substring(2) + ";";
+      }
+
+      // Merge children
+      if (!this.isChild) {
+        this.source[1] += '\n' + this.context.programs.join('\n') + '\n';
+      }
+
+      if (!this.environment.isSimple) {
+        this.source.push("return buffer;");
+      }
+
+      var params = this.isChild ? ["depth0", "data"] : ["Handlebars", "depth0", "helpers", "partials", "data"];
+
+      for(var i=0, l=this.environment.depths.list.length; i<l; i++) {
+        params.push("depth" + this.environment.depths.list[i]);
+      }
+
+      if (asObject) {
+        params.push(this.source.join("\n  "));
+
+        return Function.apply(this, params);
+      } else {
+        var functionSource = 'function ' + (this.name || '') + '(' + params.join(',') + ') {\n  ' + this.source.join("\n  ") + '}';
+        Handlebars.log(Handlebars.logger.DEBUG, functionSource + "\n\n");
+        return functionSource;
+      }
+    },
+
+    // [blockValue]
+    //
+    // On stack, before: hash, inverse, program, value
+    // On stack, after: return value of blockHelperMissing
+    //
+    // The purpose of this opcode is to take a block of the form
+    // `{{#foo}}...{{/foo}}`, resolve the value of `foo`, and
+    // replace it on the stack with the result of properly
+    // invoking blockHelperMissing.
+    blockValue: function() {
+      this.context.aliases.blockHelperMissing = 'helpers.blockHelperMissing';
+
+      var params = ["depth0"];
+      this.setupParams(0, params);
+
+      this.replaceStack(function(current) {
+        params.splice(1, 0, current);
+        return current + " = blockHelperMissing.call(" + params.join(", ") + ")";
+      });
+    },
+
+    // [ambiguousBlockValue]
+    //
+    // On stack, before: hash, inverse, program, value
+    // Compiler value, before: lastHelper=value of last found helper, if any
+    // On stack, after, if no lastHelper: same as [blockValue]
+    // On stack, after, if lastHelper: value
+    ambiguousBlockValue: function() {
+      this.context.aliases.blockHelperMissing = 'helpers.blockHelperMissing';
+
+      var params = ["depth0"];
+      this.setupParams(0, params);
+
+      var current = this.topStack();
+      params.splice(1, 0, current);
+
+      this.source.push("if (!" + this.lastHelper + ") { " + current + " = blockHelperMissing.call(" + params.join(", ") + "); }");
+    },
+
+    // [appendContent]
+    //
+    // On stack, before: ...
+    // On stack, after: ...
+    //
+    // Appends the string value of `content` to the current buffer
+    appendContent: function(content) {
+      this.source.push(this.appendToBuffer(this.quotedString(content)));
+    },
+
+    // [append]
+    //
+    // On stack, before: value, ...
+    // On stack, after: ...
+    //
+    // Coerces `value` to a String and appends it to the current buffer.
+    //
+    // If `value` is truthy, or 0, it is coerced into a string and appended
+    // Otherwise, the empty string is appended
+    append: function() {
+      var local = this.popStack();
+      this.source.push("if(" + local + " || " + local + " === 0) { " + this.appendToBuffer(local) + " }");
+      if (this.environment.isSimple) {
+        this.source.push("else { " + this.appendToBuffer("''") + " }");
+      }
+    },
+
+    // [appendEscaped]
+    //
+    // On stack, before: value, ...
+    // On stack, after: ...
+    //
+    // Escape `value` and append it to the buffer
+    appendEscaped: function() {
+      var opcode = this.nextOpcode(), extra = "";
+      this.context.aliases.escapeExpression = 'this.escapeExpression';
+
+      if(opcode && opcode.opcode === 'appendContent') {
+        extra = " + " + this.quotedString(opcode.args[0]);
+        this.eat(opcode);
+      }
+
+      this.source.push(this.appendToBuffer("escapeExpression(" + this.popStack() + ")" + extra));
+    },
+
+    // [getContext]
+    //
+    // On stack, before: ...
+    // On stack, after: ...
+    // Compiler value, after: lastContext=depth
+    //
+    // Set the value of the `lastContext` compiler value to the depth
+    getContext: function(depth) {
+      if(this.lastContext !== depth) {
+        this.lastContext = depth;
+      }
+    },
+
+    // [lookupOnContext]
+    //
+    // On stack, before: ...
+    // On stack, after: currentContext[name], ...
+    //
+    // Looks up the value of `name` on the current context and pushes
+    // it onto the stack.
+    lookupOnContext: function(name) {
+      this.pushStack(this.nameLookup('depth' + this.lastContext, name, 'context'));
+    },
+
+    // [pushContext]
+    //
+    // On stack, before: ...
+    // On stack, after: currentContext, ...
+    //
+    // Pushes the value of the current context onto the stack.
+    pushContext: function() {
+      this.pushStackLiteral('depth' + this.lastContext);
+    },
+
+    // [resolvePossibleLambda]
+    //
+    // On stack, before: value, ...
+    // On stack, after: resolved value, ...
+    //
+    // If the `value` is a lambda, replace it on the stack by
+    // the return value of the lambda
+    resolvePossibleLambda: function() {
+      this.context.aliases.functionType = '"function"';
+
+      this.replaceStack(function(current) {
+        return "typeof " + current + " === functionType ? " + current + "() : " + current;
+      });
+    },
+
+    // [lookup]
+    //
+    // On stack, before: value, ...
+    // On stack, after: value[name], ...
+    //
+    // Replace the value on the stack with the result of looking
+    // up `name` on `value`
+    lookup: function(name) {
+      this.replaceStack(function(current) {
+        return current + " == null || " + current + " === false ? " + current + " : " + this.nameLookup(current, name, 'context');
+      });
+    },
+
+    // [lookupData]
+    //
+    // On stack, before: ...
+    // On stack, after: data[id], ...
+    //
+    // Push the result of looking up `id` on the current data
+    lookupData: function(id) {
+      this.pushStack(this.nameLookup('data', id, 'data'));
+    },
+
+    // [pushStringParam]
+    //
+    // On stack, before: ...
+    // On stack, after: string, currentContext, ...
+    //
+    // This opcode is designed for use in string mode, which
+    // provides the string value of a parameter along with its
+    // depth rather than resolving it immediately.
+    pushStringParam: function(string) {
+      this.pushStackLiteral('depth' + this.lastContext);
+      this.pushString(string);
+    },
+
+    // [pushString]
+    //
+    // On stack, before: ...
+    // On stack, after: quotedString(string), ...
+    //
+    // Push a quoted version of `string` onto the stack
+    pushString: function(string) {
+      this.pushStackLiteral(this.quotedString(string));
+    },
+
+    // [push]
+    //
+    // On stack, before: ...
+    // On stack, after: expr, ...
+    //
+    // Push an expression onto the stack
+    push: function(expr) {
+      this.pushStack(expr);
+    },
+
+    // [pushLiteral]
+    //
+    // On stack, before: ...
+    // On stack, after: value, ...
+    //
+    // Pushes a value onto the stack. This operation prevents
+    // the compiler from creating a temporary variable to hold
+    // it.
+    pushLiteral: function(value) {
+      this.pushStackLiteral(value);
+    },
+
+    // [pushProgram]
+    //
+    // On stack, before: ...
+    // On stack, after: program(guid), ...
+    //
+    // Push a program expression onto the stack. This takes
+    // a compile-time guid and converts it into a runtime-accessible
+    // expression.
+    pushProgram: function(guid) {
+      if (guid != null) {
+        this.pushStackLiteral(this.programExpression(guid));
+      } else {
+        this.pushStackLiteral(null);
+      }
+    },
+
+    // [invokeHelper]
+    //
+    // On stack, before: hash, inverse, program, params..., ...
+    // On stack, after: result of helper invocation
+    //
+    // Pops off the helper's parameters, invokes the helper,
+    // and pushes the helper's return value onto the stack.
+    //
+    // If the helper is not found, `helperMissing` is called.
+    invokeHelper: function(paramSize, name) {
+      this.context.aliases.helperMissing = 'helpers.helperMissing';
+
+      var helper = this.lastHelper = this.setupHelper(paramSize, name);
+      this.register('foundHelper', helper.name);
+
+      this.pushStack("foundHelper ? foundHelper.call(" +
+        helper.callParams + ") " + ": helperMissing.call(" +
+        helper.helperMissingParams + ")");
+    },
+
+    // [invokeKnownHelper]
+    //
+    // On stack, before: hash, inverse, program, params..., ...
+    // On stack, after: result of helper invocation
+    //
+    // This operation is used when the helper is known to exist,
+    // so a `helperMissing` fallback is not required.
+    invokeKnownHelper: function(paramSize, name) {
+      var helper = this.setupHelper(paramSize, name);
+      this.pushStack(helper.name + ".call(" + helper.callParams + ")");
+    },
+
+    // [invokeAmbiguous]
+    //
+    // On stack, before: hash, inverse, program, params..., ...
+    // On stack, after: result of disambiguation
+    //
+    // This operation is used when an expression like `{{foo}}`
+    // is provided, but we don't know at compile-time whether it
+    // is a helper or a path.
+    //
+    // This operation emits more code than the other options,
+    // and can be avoided by passing the `knownHelpers` and
+    // `knownHelpersOnly` flags at compile-time.
+    invokeAmbiguous: function(name) {
+      this.context.aliases.functionType = '"function"';
+
+      this.pushStackLiteral('{}');
+      var helper = this.setupHelper(0, name);
+
+      var helperName = this.lastHelper = this.nameLookup('helpers', name, 'helper');
+      this.register('foundHelper', helperName);
+
+      var nonHelper = this.nameLookup('depth' + this.lastContext, name, 'context');
+      var nextStack = this.nextStack();
+
+      this.source.push('if (foundHelper) { ' + nextStack + ' = foundHelper.call(' + helper.callParams + '); }');
+      this.source.push('else { ' + nextStack + ' = ' + nonHelper + '; ' + nextStack + ' = typeof ' + nextStack + ' === functionType ? ' + nextStack + '() : ' + nextStack + '; }');
+    },
+
+    // [invokePartial]
+    //
+    // On stack, before: context, ...
+    // On stack after: result of partial invocation
+    //
+    // This operation pops off a context, invokes a partial with that context,
+    // and pushes the result of the invocation back.
+    invokePartial: function(name) {
+      var params = [this.nameLookup('partials', name, 'partial'), "'" + name + "'", this.popStack(), "helpers", "partials"];
+
+      if (this.options.data) {
+        params.push("data");
+      }
+
+      this.context.aliases.self = "this";
+      this.pushStack("self.invokePartial(" + params.join(", ") + ");");
+    },
+
+    // [assignToHash]
+    //
+    // On stack, before: value, hash, ...
+    // On stack, after: hash, ...
+    //
+    // Pops a value and hash off the stack, assigns `hash[key] = value`
+    // and pushes the hash back onto the stack.
+    assignToHash: function(key) {
+      var value = this.popStack();
+      var hash = this.topStack();
+
+      this.source.push(hash + "['" + key + "'] = " + value + ";");
+    },
+
+    // HELPERS
+
+    compiler: JavaScriptCompiler,
+
+    compileChildren: function(environment, options) {
+      var children = environment.children, child, compiler;
+
+      for(var i=0, l=children.length; i<l; i++) {
+        child = children[i];
+        compiler = new this.compiler();
+
+        this.context.programs.push('');     // Placeholder to prevent name conflicts for nested children
+        var index = this.context.programs.length;
+        child.index = index;
+        child.name = 'program' + index;
+        this.context.programs[index] = compiler.compile(child, options, this.context);
+      }
+    },
+
+    programExpression: function(guid) {
+      this.context.aliases.self = "this";
+
+      if(guid == null) {
+        return "self.noop";
+      }
+
+      var child = this.environment.children[guid],
+          depths = child.depths.list, depth;
+
+      var programParams = [child.index, child.name, "data"];
+
+      for(var i=0, l = depths.length; i<l; i++) {
+        depth = depths[i];
+
+        if(depth === 1) { programParams.push("depth0"); }
+        else { programParams.push("depth" + (depth - 1)); }
+      }
+
+      if(depths.length === 0) {
+        return "self.program(" + programParams.join(", ") + ")";
+      } else {
+        programParams.shift();
+        return "self.programWithDepth(" + programParams.join(", ") + ")";
+      }
+    },
+
+    register: function(name, val) {
+      this.useRegister(name);
+      this.source.push(name + " = " + val + ";");
+    },
+
+    useRegister: function(name) {
+      if(!this.registers[name]) {
+        this.registers[name] = true;
+        this.registers.list.push(name);
+      }
+    },
+
+    pushStackLiteral: function(item) {
+      this.compileStack.push(new Literal(item));
+      return item;
+    },
+
+    pushStack: function(item) {
+      this.source.push(this.incrStack() + " = " + item + ";");
+      this.compileStack.push("stack" + this.stackSlot);
+      return "stack" + this.stackSlot;
+    },
+
+    replaceStack: function(callback) {
+      var item = callback.call(this, this.topStack());
+
+      this.source.push(this.topStack() + " = " + item + ";");
+      return "stack" + this.stackSlot;
+    },
+
+    nextStack: function(skipCompileStack) {
+      var name = this.incrStack();
+      this.compileStack.push("stack" + this.stackSlot);
+      return name;
+    },
+
+    incrStack: function() {
+      this.stackSlot++;
+      if(this.stackSlot > this.stackVars.length) { this.stackVars.push("stack" + this.stackSlot); }
+      return "stack" + this.stackSlot;
+    },
+
+    popStack: function() {
+      var item = this.compileStack.pop();
+
+      if (item instanceof Literal) {
+        return item.value;
+      } else {
+        this.stackSlot--;
+        return item;
+      }
+    },
+
+    topStack: function() {
+      var item = this.compileStack[this.compileStack.length - 1];
+
+      if (item instanceof Literal) {
+        return item.value;
+      } else {
+        return item;
+      }
+    },
+
+    quotedString: function(str) {
+      return '"' + str
+        .replace(/\\/g, '\\\\')
+        .replace(/"/g, '\\"')
+        .replace(/\n/g, '\\n')
+        .replace(/\r/g, '\\r') + '"';
+    },
+
+    setupHelper: function(paramSize, name) {
+      var params = [];
+      this.setupParams(paramSize, params);
+      var foundHelper = this.nameLookup('helpers', name, 'helper');
+
+      return {
+        params: params,
+        name: foundHelper,
+        callParams: ["depth0"].concat(params).join(", "),
+        helperMissingParams: ["depth0", this.quotedString(name)].concat(params).join(", ")
+      };
+    },
+
+    // the params and contexts arguments are passed in arrays
+    // to fill in
+    setupParams: function(paramSize, params) {
+      var options = [], contexts = [], param, inverse, program;
+
+      options.push("hash:" + this.popStack());
+
+      inverse = this.popStack();
+      program = this.popStack();
+
+      // Avoid setting fn and inverse if neither are set. This allows
+      // helpers to do a check for `if (options.fn)`
+      if (program || inverse) {
+        if (!program) {
+          this.context.aliases.self = "this";
+          program = "self.noop";
+        }
+
+        if (!inverse) {
+         this.context.aliases.self = "this";
+          inverse = "self.noop";
+        }
+
+        options.push("inverse:" + inverse);
+        options.push("fn:" + program);
+      }
+
+      for(var i=0; i<paramSize; i++) {
+        param = this.popStack();
+        params.push(param);
+
+        if(this.options.stringParams) {
+          contexts.push(this.popStack());
+        }
+      }
+
+      if (this.options.stringParams) {
+        options.push("contexts:[" + contexts.join(",") + "]");
+      }
+
+      if(this.options.data) {
+        options.push("data:data");
+      }
+
+      params.push("{" + options.join(",") + "}");
+      return params.join(", ");
+    }
+  };
+
+  var reservedWords = (
+    "break else new var" +
+    " case finally return void" +
+    " catch for switch while" +
+    " continue function this with" +
+    " default if throw" +
+    " delete in try" +
+    " do instanceof typeof" +
+    " abstract enum int short" +
+    " boolean export interface static" +
+    " byte extends long super" +
+    " char final native synchronized" +
+    " class float package throws" +
+    " const goto private transient" +
+    " debugger implements protected volatile" +
+    " double import public let yield"
+  ).split(" ");
+
+  var compilerWords = JavaScriptCompiler.RESERVED_WORDS = {};
+
+  for(var i=0, l=reservedWords.length; i<l; i++) {
+    compilerWords[reservedWords[i]] = true;
+  }
+
+  JavaScriptCompiler.isValidJavaScriptVariableName = function(name) {
+    if(!JavaScriptCompiler.RESERVED_WORDS[name] && /^[a-zA-Z_$][0-9a-zA-Z_$]+$/.test(name)) {
+      return true;
+    }
+    return false;
+  };
+
+})(Handlebars.Compiler, Handlebars.JavaScriptCompiler);
+
+Handlebars.precompile = function(string, options) {
+  options = options || {};
+
+  var ast = Handlebars.parse(string);
+  var environment = new Handlebars.Compiler().compile(ast, options);
+  return new Handlebars.JavaScriptCompiler().compile(environment, options);
+};
+
+Handlebars.compile = function(string, options) {
+  options = options || {};
+
+  var compiled;
+  function compile() {
+    var ast = Handlebars.parse(string);
+    var environment = new Handlebars.Compiler().compile(ast, options);
+    var templateSpec = new Handlebars.JavaScriptCompiler().compile(environment, options, undefined, true);
+    return Handlebars.template(templateSpec);
+  }
+
+  // Template is only compiled on first use and cached after that point.
+  return function(context, options) {
+    if (!compiled) {
+      compiled = compile();
+    }
+    return compiled.call(this, context, options);
+  };
+};
+;
+// lib/handlebars/runtime.js
+Handlebars.VM = {
+  template: function(templateSpec) {
+    // Just add water
+    var container = {
+      escapeExpression: Handlebars.Utils.escapeExpression,
+      invokePartial: Handlebars.VM.invokePartial,
+      programs: [],
+      program: function(i, fn, data) {
+        var programWrapper = this.programs[i];
+        if(data) {
+          return Handlebars.VM.program(fn, data);
+        } else if(programWrapper) {
+          return programWrapper;
+        } else {
+          programWrapper = this.programs[i] = Handlebars.VM.program(fn);
+          return programWrapper;
+        }
+      },
+      programWithDepth: Handlebars.VM.programWithDepth,
+      noop: Handlebars.VM.noop
+    };
+
+    return function(context, options) {
+      options = options || {};
+      return templateSpec.call(container, Handlebars, context, options.helpers, options.partials, options.data);
+    };
+  },
+
+  programWithDepth: function(fn, data, $depth) {
+    var args = Array.prototype.slice.call(arguments, 2);
+
+    return function(context, options) {
+      options = options || {};
+
+      return fn.apply(this, [context, options.data || data].concat(args));
+    };
+  },
+  program: function(fn, data) {
+    return function(context, options) {
+      options = options || {};
+
+      return fn(context, options.data || data);
+    };
+  },
+  noop: function() { return ""; },
+  invokePartial: function(partial, name, context, helpers, partials, data) {
+    var options = { helpers: helpers, partials: partials, data: data };
+
+    if(partial === undefined) {
+      throw new Handlebars.Exception("The partial " + name + " could not be found");
+    } else if(partial instanceof Function) {
+      return partial(context, options);
+    } else if (!Handlebars.compile) {
+      throw new Handlebars.Exception("The partial " + name + " could not be compiled when running in runtime-only mode");
+    } else {
+      partials[name] = Handlebars.compile(partial, {data: data !== undefined});
+      return partials[name](context, options);
+    }
+  }
+};
+
+Handlebars.template = Handlebars.VM.template;
+;
+
+// AMD Define
+define(function(){
+    return Handlebars;
+});
+
+})();
diff --git a/module/web/static/js/libs/backbone-0.9.10.js b/module/web/static/js/libs/backbone-0.9.10.js
new file mode 100644
index 000000000..9682be585
--- /dev/null
+++ b/module/web/static/js/libs/backbone-0.9.10.js
@@ -0,0 +1,1498 @@
+//     Backbone.js 0.9.10
+
+//     (c) 2010-2012 Jeremy Ashkenas, DocumentCloud Inc.
+//     Backbone may be freely distributed under the MIT license.
+//     For all details and documentation:
+//     http://backbonejs.org
+
+(function(){
+
+  // Initial Setup
+  // -------------
+
+  // Save a reference to the global object (`window` in the browser, `exports`
+  // on the server).
+  var root = this;
+
+  // Save the previous value of the `Backbone` variable, so that it can be
+  // restored later on, if `noConflict` is used.
+  var previousBackbone = root.Backbone;
+
+  // Create a local reference to array methods.
+  var array = [];
+  var push = array.push;
+  var slice = array.slice;
+  var splice = array.splice;
+
+  // The top-level namespace. All public Backbone classes and modules will
+  // be attached to this. Exported for both CommonJS and the browser.
+  var Backbone;
+  if (typeof exports !== 'undefined') {
+    Backbone = exports;
+  } else {
+    Backbone = root.Backbone = {};
+  }
+
+  // Current version of the library. Keep in sync with `package.json`.
+  Backbone.VERSION = '0.9.10';
+
+  // Require Underscore, if we're on the server, and it's not already present.
+  var _ = root._;
+  if (!_ && (typeof require !== 'undefined')) _ = require('underscore');
+
+  // For Backbone's purposes, jQuery, Zepto, or Ender owns the `$` variable.
+  Backbone.$ = root.jQuery || root.Zepto || root.ender;
+
+  // Runs Backbone.js in *noConflict* mode, returning the `Backbone` variable
+  // to its previous owner. Returns a reference to this Backbone object.
+  Backbone.noConflict = function() {
+    root.Backbone = previousBackbone;
+    return this;
+  };
+
+  // Turn on `emulateHTTP` to support legacy HTTP servers. Setting this option
+  // will fake `"PUT"` and `"DELETE"` requests via the `_method` parameter and
+  // set a `X-Http-Method-Override` header.
+  Backbone.emulateHTTP = false;
+
+  // Turn on `emulateJSON` to support legacy servers that can't deal with direct
+  // `application/json` requests ... will encode the body as
+  // `application/x-www-form-urlencoded` instead and will send the model in a
+  // form param named `model`.
+  Backbone.emulateJSON = false;
+
+  // Backbone.Events
+  // ---------------
+
+  // Regular expression used to split event strings.
+  var eventSplitter = /\s+/;
+
+  // Implement fancy features of the Events API such as multiple event
+  // names `"change blur"` and jQuery-style event maps `{change: action}`
+  // in terms of the existing API.
+  var eventsApi = function(obj, action, name, rest) {
+    if (!name) return true;
+    if (typeof name === 'object') {
+      for (var key in name) {
+        obj[action].apply(obj, [key, name[key]].concat(rest));
+      }
+    } else if (eventSplitter.test(name)) {
+      var names = name.split(eventSplitter);
+      for (var i = 0, l = names.length; i < l; i++) {
+        obj[action].apply(obj, [names[i]].concat(rest));
+      }
+    } else {
+      return true;
+    }
+  };
+
+  // Optimized internal dispatch function for triggering events. Tries to
+  // keep the usual cases speedy (most Backbone events have 3 arguments).
+  var triggerEvents = function(events, args) {
+    var ev, i = -1, l = events.length;
+    switch (args.length) {
+    case 0: while (++i < l) (ev = events[i]).callback.call(ev.ctx);
+    return;
+    case 1: while (++i < l) (ev = events[i]).callback.call(ev.ctx, args[0]);
+    return;
+    case 2: while (++i < l) (ev = events[i]).callback.call(ev.ctx, args[0], args[1]);
+    return;
+    case 3: while (++i < l) (ev = events[i]).callback.call(ev.ctx, args[0], args[1], args[2]);
+    return;
+    default: while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args);
+    }
+  };
+
+  // A module that can be mixed in to *any object* in order to provide it with
+  // custom events. You may bind with `on` or remove with `off` callback
+  // functions to an event; `trigger`-ing an event fires all callbacks in
+  // succession.
+  //
+  //     var object = {};
+  //     _.extend(object, Backbone.Events);
+  //     object.on('expand', function(){ alert('expanded'); });
+  //     object.trigger('expand');
+  //
+  var Events = Backbone.Events = {
+
+    // Bind one or more space separated events, or an events map,
+    // to a `callback` function. Passing `"all"` will bind the callback to
+    // all events fired.
+    on: function(name, callback, context) {
+      if (!(eventsApi(this, 'on', name, [callback, context]) && callback)) return this;
+      this._events || (this._events = {});
+      var list = this._events[name] || (this._events[name] = []);
+      list.push({callback: callback, context: context, ctx: context || this});
+      return this;
+    },
+
+    // Bind events to only be triggered a single time. After the first time
+    // the callback is invoked, it will be removed.
+    once: function(name, callback, context) {
+      if (!(eventsApi(this, 'once', name, [callback, context]) && callback)) return this;
+      var self = this;
+      var once = _.once(function() {
+        self.off(name, once);
+        callback.apply(this, arguments);
+      });
+      once._callback = callback;
+      this.on(name, once, context);
+      return this;
+    },
+
+    // Remove one or many callbacks. If `context` is null, removes all
+    // callbacks with that function. If `callback` is null, removes all
+    // callbacks for the event. If `name` is null, removes all bound
+    // callbacks for all events.
+    off: function(name, callback, context) {
+      var list, ev, events, names, i, l, j, k;
+      if (!this._events || !eventsApi(this, 'off', name, [callback, context])) return this;
+      if (!name && !callback && !context) {
+        this._events = {};
+        return this;
+      }
+
+      names = name ? [name] : _.keys(this._events);
+      for (i = 0, l = names.length; i < l; i++) {
+        name = names[i];
+        if (list = this._events[name]) {
+          events = [];
+          if (callback || context) {
+            for (j = 0, k = list.length; j < k; j++) {
+              ev = list[j];
+              if ((callback && callback !== ev.callback &&
+                               callback !== ev.callback._callback) ||
+                  (context && context !== ev.context)) {
+                events.push(ev);
+              }
+            }
+          }
+          this._events[name] = events;
+        }
+      }
+
+      return this;
+    },
+
+    // Trigger one or many events, firing all bound callbacks. Callbacks are
+    // passed the same arguments as `trigger` is, apart from the event name
+    // (unless you're listening on `"all"`, which will cause your callback to
+    // receive the true name of the event as the first argument).
+    trigger: function(name) {
+      if (!this._events) return this;
+      var args = slice.call(arguments, 1);
+      if (!eventsApi(this, 'trigger', name, args)) return this;
+      var events = this._events[name];
+      var allEvents = this._events.all;
+      if (events) triggerEvents(events, args);
+      if (allEvents) triggerEvents(allEvents, arguments);
+      return this;
+    },
+
+    // An inversion-of-control version of `on`. Tell *this* object to listen to
+    // an event in another object ... keeping track of what it's listening to.
+    listenTo: function(obj, name, callback) {
+      var listeners = this._listeners || (this._listeners = {});
+      var id = obj._listenerId || (obj._listenerId = _.uniqueId('l'));
+      listeners[id] = obj;
+      obj.on(name, typeof name === 'object' ? this : callback, this);
+      return this;
+    },
+
+    // Tell this object to stop listening to either specific events ... or
+    // to every object it's currently listening to.
+    stopListening: function(obj, name, callback) {
+      var listeners = this._listeners;
+      if (!listeners) return;
+      if (obj) {
+        obj.off(name, typeof name === 'object' ? this : callback, this);
+        if (!name && !callback) delete listeners[obj._listenerId];
+      } else {
+        if (typeof name === 'object') callback = this;
+        for (var id in listeners) {
+          listeners[id].off(name, callback, this);
+        }
+        this._listeners = {};
+      }
+      return this;
+    }
+  };
+
+  // Aliases for backwards compatibility.
+  Events.bind   = Events.on;
+  Events.unbind = Events.off;
+
+  // Allow the `Backbone` object to serve as a global event bus, for folks who
+  // want global "pubsub" in a convenient place.
+  _.extend(Backbone, Events);
+
+  // Backbone.Model
+  // --------------
+
+  // Create a new model, with defined attributes. A client id (`cid`)
+  // is automatically generated and assigned for you.
+  var Model = Backbone.Model = function(attributes, options) {
+    var defaults;
+    var attrs = attributes || {};
+    this.cid = _.uniqueId('c');
+    this.attributes = {};
+    if (options && options.collection) this.collection = options.collection;
+    if (options && options.parse) attrs = this.parse(attrs, options) || {};
+    if (defaults = _.result(this, 'defaults')) {
+      attrs = _.defaults({}, attrs, defaults);
+    }
+    this.set(attrs, options);
+    this.changed = {};
+    this.initialize.apply(this, arguments);
+  };
+
+  // Attach all inheritable methods to the Model prototype.
+  _.extend(Model.prototype, Events, {
+
+    // A hash of attributes whose current and previous value differ.
+    changed: null,
+
+    // The default name for the JSON `id` attribute is `"id"`. MongoDB and
+    // CouchDB users may want to set this to `"_id"`.
+    idAttribute: 'id',
+
+    // Initialize is an empty function by default. Override it with your own
+    // initialization logic.
+    initialize: function(){},
+
+    // Return a copy of the model's `attributes` object.
+    toJSON: function(options) {
+      return _.clone(this.attributes);
+    },
+
+    // Proxy `Backbone.sync` by default.
+    sync: function() {
+      return Backbone.sync.apply(this, arguments);
+    },
+
+    // Get the value of an attribute.
+    get: function(attr) {
+      return this.attributes[attr];
+    },
+
+    // Get the HTML-escaped value of an attribute.
+    escape: function(attr) {
+      return _.escape(this.get(attr));
+    },
+
+    // Returns `true` if the attribute contains a value that is not null
+    // or undefined.
+    has: function(attr) {
+      return this.get(attr) != null;
+    },
+
+    // ----------------------------------------------------------------------
+
+    // Set a hash of model attributes on the object, firing `"change"` unless
+    // you choose to silence it.
+    set: function(key, val, options) {
+      var attr, attrs, unset, changes, silent, changing, prev, current;
+      if (key == null) return this;
+
+      // Handle both `"key", value` and `{key: value}` -style arguments.
+      if (typeof key === 'object') {
+        attrs = key;
+        options = val;
+      } else {
+        (attrs = {})[key] = val;
+      }
+
+      options || (options = {});
+
+      // Run validation.
+      if (!this._validate(attrs, options)) return false;
+
+      // Extract attributes and options.
+      unset           = options.unset;
+      silent          = options.silent;
+      changes         = [];
+      changing        = this._changing;
+      this._changing  = true;
+
+      if (!changing) {
+        this._previousAttributes = _.clone(this.attributes);
+        this.changed = {};
+      }
+      current = this.attributes, prev = this._previousAttributes;
+
+      // Check for changes of `id`.
+      if (this.idAttribute in attrs) this.id = attrs[this.idAttribute];
+
+      // For each `set` attribute, update or delete the current value.
+      for (attr in attrs) {
+        val = attrs[attr];
+        if (!_.isEqual(current[attr], val)) changes.push(attr);
+        if (!_.isEqual(prev[attr], val)) {
+          this.changed[attr] = val;
+        } else {
+          delete this.changed[attr];
+        }
+        unset ? delete current[attr] : current[attr] = val;
+      }
+
+      // Trigger all relevant attribute changes.
+      if (!silent) {
+        if (changes.length) this._pending = true;
+        for (var i = 0, l = changes.length; i < l; i++) {
+          this.trigger('change:' + changes[i], this, current[changes[i]], options);
+        }
+      }
+
+      if (changing) return this;
+      if (!silent) {
+        while (this._pending) {
+          this._pending = false;
+          this.trigger('change', this, options);
+        }
+      }
+      this._pending = false;
+      this._changing = false;
+      return this;
+    },
+
+    // Remove an attribute from the model, firing `"change"` unless you choose
+    // to silence it. `unset` is a noop if the attribute doesn't exist.
+    unset: function(attr, options) {
+      return this.set(attr, void 0, _.extend({}, options, {unset: true}));
+    },
+
+    // Clear all attributes on the model, firing `"change"` unless you choose
+    // to silence it.
+    clear: function(options) {
+      var attrs = {};
+      for (var key in this.attributes) attrs[key] = void 0;
+      return this.set(attrs, _.extend({}, options, {unset: true}));
+    },
+
+    // Determine if the model has changed since the last `"change"` event.
+    // If you specify an attribute name, determine if that attribute has changed.
+    hasChanged: function(attr) {
+      if (attr == null) return !_.isEmpty(this.changed);
+      return _.has(this.changed, attr);
+    },
+
+    // Return an object containing all the attributes that have changed, or
+    // false if there are no changed attributes. Useful for determining what
+    // parts of a view need to be updated and/or what attributes need to be
+    // persisted to the server. Unset attributes will be set to undefined.
+    // You can also pass an attributes object to diff against the model,
+    // determining if there *would be* a change.
+    changedAttributes: function(diff) {
+      if (!diff) return this.hasChanged() ? _.clone(this.changed) : false;
+      var val, changed = false;
+      var old = this._changing ? this._previousAttributes : this.attributes;
+      for (var attr in diff) {
+        if (_.isEqual(old[attr], (val = diff[attr]))) continue;
+        (changed || (changed = {}))[attr] = val;
+      }
+      return changed;
+    },
+
+    // Get the previous value of an attribute, recorded at the time the last
+    // `"change"` event was fired.
+    previous: function(attr) {
+      if (attr == null || !this._previousAttributes) return null;
+      return this._previousAttributes[attr];
+    },
+
+    // Get all of the attributes of the model at the time of the previous
+    // `"change"` event.
+    previousAttributes: function() {
+      return _.clone(this._previousAttributes);
+    },
+
+    // ---------------------------------------------------------------------
+
+    // Fetch the model from the server. If the server's representation of the
+    // model differs from its current attributes, they will be overriden,
+    // triggering a `"change"` event.
+    fetch: function(options) {
+      options = options ? _.clone(options) : {};
+      if (options.parse === void 0) options.parse = true;
+      var success = options.success;
+      options.success = function(model, resp, options) {
+        if (!model.set(model.parse(resp, options), options)) return false;
+        if (success) success(model, resp, options);
+      };
+      return this.sync('read', this, options);
+    },
+
+    // Set a hash of model attributes, and sync the model to the server.
+    // If the server returns an attributes hash that differs, the model's
+    // state will be `set` again.
+    save: function(key, val, options) {
+      var attrs, success, method, xhr, attributes = this.attributes;
+
+      // Handle both `"key", value` and `{key: value}` -style arguments.
+      if (key == null || typeof key === 'object') {
+        attrs = key;
+        options = val;
+      } else {
+        (attrs = {})[key] = val;
+      }
+
+      // If we're not waiting and attributes exist, save acts as `set(attr).save(null, opts)`.
+      if (attrs && (!options || !options.wait) && !this.set(attrs, options)) return false;
+
+      options = _.extend({validate: true}, options);
+
+      // Do not persist invalid models.
+      if (!this._validate(attrs, options)) return false;
+
+      // Set temporary attributes if `{wait: true}`.
+      if (attrs && options.wait) {
+        this.attributes = _.extend({}, attributes, attrs);
+      }
+
+      // After a successful server-side save, the client is (optionally)
+      // updated with the server-side state.
+      if (options.parse === void 0) options.parse = true;
+      success = options.success;
+      options.success = function(model, resp, options) {
+        // Ensure attributes are restored during synchronous saves.
+        model.attributes = attributes;
+        var serverAttrs = model.parse(resp, options);
+        if (options.wait) serverAttrs = _.extend(attrs || {}, serverAttrs);
+        if (_.isObject(serverAttrs) && !model.set(serverAttrs, options)) {
+          return false;
+        }
+        if (success) success(model, resp, options);
+      };
+
+      // Finish configuring and sending the Ajax request.
+      method = this.isNew() ? 'create' : (options.patch ? 'patch' : 'update');
+      if (method === 'patch') options.attrs = attrs;
+      xhr = this.sync(method, this, options);
+
+      // Restore attributes.
+      if (attrs && options.wait) this.attributes = attributes;
+
+      return xhr;
+    },
+
+    // Destroy this model on the server if it was already persisted.
+    // Optimistically removes the model from its collection, if it has one.
+    // If `wait: true` is passed, waits for the server to respond before removal.
+    destroy: function(options) {
+      options = options ? _.clone(options) : {};
+      var model = this;
+      var success = options.success;
+
+      var destroy = function() {
+        model.trigger('destroy', model, model.collection, options);
+      };
+
+      options.success = function(model, resp, options) {
+        if (options.wait || model.isNew()) destroy();
+        if (success) success(model, resp, options);
+      };
+
+      if (this.isNew()) {
+        options.success(this, null, options);
+        return false;
+      }
+
+      var xhr = this.sync('delete', this, options);
+      if (!options.wait) destroy();
+      return xhr;
+    },
+
+    // Default URL for the model's representation on the server -- if you're
+    // using Backbone's restful methods, override this to change the endpoint
+    // that will be called.
+    url: function() {
+      var base = _.result(this, 'urlRoot') || _.result(this.collection, 'url') || urlError();
+      if (this.isNew()) return base;
+      return base + (base.charAt(base.length - 1) === '/' ? '' : '/') + encodeURIComponent(this.id);
+    },
+
+    // **parse** converts a response into the hash of attributes to be `set` on
+    // the model. The default implementation is just to pass the response along.
+    parse: function(resp, options) {
+      return resp;
+    },
+
+    // Create a new model with identical attributes to this one.
+    clone: function() {
+      return new this.constructor(this.attributes);
+    },
+
+    // A model is new if it has never been saved to the server, and lacks an id.
+    isNew: function() {
+      return this.id == null;
+    },
+
+    // Check if the model is currently in a valid state.
+    isValid: function(options) {
+      return !this.validate || !this.validate(this.attributes, options);
+    },
+
+    // Run validation against the next complete set of model attributes,
+    // returning `true` if all is well. Otherwise, fire a general
+    // `"error"` event and call the error callback, if specified.
+    _validate: function(attrs, options) {
+      if (!options.validate || !this.validate) return true;
+      attrs = _.extend({}, this.attributes, attrs);
+      var error = this.validationError = this.validate(attrs, options) || null;
+      if (!error) return true;
+      this.trigger('invalid', this, error, options || {});
+      return false;
+    }
+
+  });
+
+  // Backbone.Collection
+  // -------------------
+
+  // Provides a standard collection class for our sets of models, ordered
+  // or unordered. If a `comparator` is specified, the Collection will maintain
+  // its models in sort order, as they're added and removed.
+  var Collection = Backbone.Collection = function(models, options) {
+    options || (options = {});
+    if (options.model) this.model = options.model;
+    if (options.comparator !== void 0) this.comparator = options.comparator;
+    this.models = [];
+    this._reset();
+    this.initialize.apply(this, arguments);
+    if (models) this.reset(models, _.extend({silent: true}, options));
+  };
+
+  // Define the Collection's inheritable methods.
+  _.extend(Collection.prototype, Events, {
+
+    // The default model for a collection is just a **Backbone.Model**.
+    // This should be overridden in most cases.
+    model: Model,
+
+    // Initialize is an empty function by default. Override it with your own
+    // initialization logic.
+    initialize: function(){},
+
+    // The JSON representation of a Collection is an array of the
+    // models' attributes.
+    toJSON: function(options) {
+      return this.map(function(model){ return model.toJSON(options); });
+    },
+
+    // Proxy `Backbone.sync` by default.
+    sync: function() {
+      return Backbone.sync.apply(this, arguments);
+    },
+
+    // Add a model, or list of models to the set.
+    add: function(models, options) {
+      models = _.isArray(models) ? models.slice() : [models];
+      options || (options = {});
+      var i, l, model, attrs, existing, doSort, add, at, sort, sortAttr;
+      add = [];
+      at = options.at;
+      sort = this.comparator && (at == null) && options.sort != false;
+      sortAttr = _.isString(this.comparator) ? this.comparator : null;
+
+      // Turn bare objects into model references, and prevent invalid models
+      // from being added.
+      for (i = 0, l = models.length; i < l; i++) {
+        if (!(model = this._prepareModel(attrs = models[i], options))) {
+          this.trigger('invalid', this, attrs, options);
+          continue;
+        }
+
+        // If a duplicate is found, prevent it from being added and
+        // optionally merge it into the existing model.
+        if (existing = this.get(model)) {
+          if (options.merge) {
+            existing.set(attrs === model ? model.attributes : attrs, options);
+            if (sort && !doSort && existing.hasChanged(sortAttr)) doSort = true;
+          }
+          continue;
+        }
+
+        // This is a new model, push it to the `add` list.
+        add.push(model);
+
+        // Listen to added models' events, and index models for lookup by
+        // `id` and by `cid`.
+        model.on('all', this._onModelEvent, this);
+        this._byId[model.cid] = model;
+        if (model.id != null) this._byId[model.id] = model;
+      }
+
+      // See if sorting is needed, update `length` and splice in new models.
+      if (add.length) {
+        if (sort) doSort = true;
+        this.length += add.length;
+        if (at != null) {
+          splice.apply(this.models, [at, 0].concat(add));
+        } else {
+          push.apply(this.models, add);
+        }
+      }
+
+      // Silently sort the collection if appropriate.
+      if (doSort) this.sort({silent: true});
+
+      if (options.silent) return this;
+
+      // Trigger `add` events.
+      for (i = 0, l = add.length; i < l; i++) {
+        (model = add[i]).trigger('add', model, this, options);
+      }
+
+      // Trigger `sort` if the collection was sorted.
+      if (doSort) this.trigger('sort', this, options);
+
+      return this;
+    },
+
+    // Remove a model, or a list of models from the set.
+    remove: function(models, options) {
+      models = _.isArray(models) ? models.slice() : [models];
+      options || (options = {});
+      var i, l, index, model;
+      for (i = 0, l = models.length; i < l; i++) {
+        model = this.get(models[i]);
+        if (!model) continue;
+        delete this._byId[model.id];
+        delete this._byId[model.cid];
+        index = this.indexOf(model);
+        this.models.splice(index, 1);
+        this.length--;
+        if (!options.silent) {
+          options.index = index;
+          model.trigger('remove', model, this, options);
+        }
+        this._removeReference(model);
+      }
+      return this;
+    },
+
+    // Add a model to the end of the collection.
+    push: function(model, options) {
+      model = this._prepareModel(model, options);
+      this.add(model, _.extend({at: this.length}, options));
+      return model;
+    },
+
+    // Remove a model from the end of the collection.
+    pop: function(options) {
+      var model = this.at(this.length - 1);
+      this.remove(model, options);
+      return model;
+    },
+
+    // Add a model to the beginning of the collection.
+    unshift: function(model, options) {
+      model = this._prepareModel(model, options);
+      this.add(model, _.extend({at: 0}, options));
+      return model;
+    },
+
+    // Remove a model from the beginning of the collection.
+    shift: function(options) {
+      var model = this.at(0);
+      this.remove(model, options);
+      return model;
+    },
+
+    // Slice out a sub-array of models from the collection.
+    slice: function(begin, end) {
+      return this.models.slice(begin, end);
+    },
+
+    // Get a model from the set by id.
+    get: function(obj) {
+      if (obj == null) return void 0;
+      this._idAttr || (this._idAttr = this.model.prototype.idAttribute);
+      return this._byId[obj.id || obj.cid || obj[this._idAttr] || obj];
+    },
+
+    // Get the model at the given index.
+    at: function(index) {
+      return this.models[index];
+    },
+
+    // Return models with matching attributes. Useful for simple cases of `filter`.
+    where: function(attrs) {
+      if (_.isEmpty(attrs)) return [];
+      return this.filter(function(model) {
+        for (var key in attrs) {
+          if (attrs[key] !== model.get(key)) return false;
+        }
+        return true;
+      });
+    },
+
+    // Force the collection to re-sort itself. You don't need to call this under
+    // normal circumstances, as the set will maintain sort order as each item
+    // is added.
+    sort: function(options) {
+      if (!this.comparator) {
+        throw new Error('Cannot sort a set without a comparator');
+      }
+      options || (options = {});
+
+      // Run sort based on type of `comparator`.
+      if (_.isString(this.comparator) || this.comparator.length === 1) {
+        this.models = this.sortBy(this.comparator, this);
+      } else {
+        this.models.sort(_.bind(this.comparator, this));
+      }
+
+      if (!options.silent) this.trigger('sort', this, options);
+      return this;
+    },
+
+    // Pluck an attribute from each model in the collection.
+    pluck: function(attr) {
+      return _.invoke(this.models, 'get', attr);
+    },
+
+    // Smartly update a collection with a change set of models, adding,
+    // removing, and merging as necessary.
+    update: function(models, options) {
+      options = _.extend({add: true, merge: true, remove: true}, options);
+      if (options.parse) models = this.parse(models, options);
+      var model, i, l, existing;
+      var add = [], remove = [], modelMap = {};
+
+      // Allow a single model (or no argument) to be passed.
+      if (!_.isArray(models)) models = models ? [models] : [];
+
+      // Proxy to `add` for this case, no need to iterate...
+      if (options.add && !options.remove) return this.add(models, options);
+
+      // Determine which models to add and merge, and which to remove.
+      for (i = 0, l = models.length; i < l; i++) {
+        model = models[i];
+        existing = this.get(model);
+        if (options.remove && existing) modelMap[existing.cid] = true;
+        if ((options.add && !existing) || (options.merge && existing)) {
+          add.push(model);
+        }
+      }
+      if (options.remove) {
+        for (i = 0, l = this.models.length; i < l; i++) {
+          model = this.models[i];
+          if (!modelMap[model.cid]) remove.push(model);
+        }
+      }
+
+      // Remove models (if applicable) before we add and merge the rest.
+      if (remove.length) this.remove(remove, options);
+      if (add.length) this.add(add, options);
+      return this;
+    },
+
+    // When you have more items than you want to add or remove individually,
+    // you can reset the entire set with a new list of models, without firing
+    // any `add` or `remove` events. Fires `reset` when finished.
+    reset: function(models, options) {
+      options || (options = {});
+      if (options.parse) models = this.parse(models, options);
+      for (var i = 0, l = this.models.length; i < l; i++) {
+        this._removeReference(this.models[i]);
+      }
+      options.previousModels = this.models.slice();
+      this._reset();
+      if (models) this.add(models, _.extend({silent: true}, options));
+      if (!options.silent) this.trigger('reset', this, options);
+      return this;
+    },
+
+    // Fetch the default set of models for this collection, resetting the
+    // collection when they arrive. If `update: true` is passed, the response
+    // data will be passed through the `update` method instead of `reset`.
+    fetch: function(options) {
+      options = options ? _.clone(options) : {};
+      if (options.parse === void 0) options.parse = true;
+      var success = options.success;
+      options.success = function(collection, resp, options) {
+        var method = options.update ? 'update' : 'reset';
+        collection[method](resp, options);
+        if (success) success(collection, resp, options);
+      };
+      return this.sync('read', this, options);
+    },
+
+    // Create a new instance of a model in this collection. Add the model to the
+    // collection immediately, unless `wait: true` is passed, in which case we
+    // wait for the server to agree.
+    create: function(model, options) {
+      options = options ? _.clone(options) : {};
+      if (!(model = this._prepareModel(model, options))) return false;
+      if (!options.wait) this.add(model, options);
+      var collection = this;
+      var success = options.success;
+      options.success = function(model, resp, options) {
+        if (options.wait) collection.add(model, options);
+        if (success) success(model, resp, options);
+      };
+      model.save(null, options);
+      return model;
+    },
+
+    // **parse** converts a response into a list of models to be added to the
+    // collection. The default implementation is just to pass it through.
+    parse: function(resp, options) {
+      return resp;
+    },
+
+    // Create a new collection with an identical list of models as this one.
+    clone: function() {
+      return new this.constructor(this.models);
+    },
+
+    // Reset all internal state. Called when the collection is reset.
+    _reset: function() {
+      this.length = 0;
+      this.models.length = 0;
+      this._byId  = {};
+    },
+
+    // Prepare a model or hash of attributes to be added to this collection.
+    _prepareModel: function(attrs, options) {
+      if (attrs instanceof Model) {
+        if (!attrs.collection) attrs.collection = this;
+        return attrs;
+      }
+      options || (options = {});
+      options.collection = this;
+      var model = new this.model(attrs, options);
+      if (!model._validate(attrs, options)) return false;
+      return model;
+    },
+
+    // Internal method to remove a model's ties to a collection.
+    _removeReference: function(model) {
+      if (this === model.collection) delete model.collection;
+      model.off('all', this._onModelEvent, this);
+    },
+
+    // Internal method called every time a model in the set fires an event.
+    // Sets need to update their indexes when models change ids. All other
+    // events simply proxy through. "add" and "remove" events that originate
+    // in other collections are ignored.
+    _onModelEvent: function(event, model, collection, options) {
+      if ((event === 'add' || event === 'remove') && collection !== this) return;
+      if (event === 'destroy') this.remove(model, options);
+      if (model && event === 'change:' + model.idAttribute) {
+        delete this._byId[model.previous(model.idAttribute)];
+        if (model.id != null) this._byId[model.id] = model;
+      }
+      this.trigger.apply(this, arguments);
+    },
+
+    sortedIndex: function (model, value, context) {
+      value || (value = this.comparator);
+      var iterator = _.isFunction(value) ? value : function(model) {
+        return model.get(value);
+      };
+      return _.sortedIndex(this.models, model, iterator, context);
+    }
+
+  });
+
+  // Underscore methods that we want to implement on the Collection.
+  var methods = ['forEach', 'each', 'map', 'collect', 'reduce', 'foldl',
+    'inject', 'reduceRight', 'foldr', 'find', 'detect', 'filter', 'select',
+    'reject', 'every', 'all', 'some', 'any', 'include', 'contains', 'invoke',
+    'max', 'min', 'toArray', 'size', 'first', 'head', 'take', 'initial', 'rest',
+    'tail', 'drop', 'last', 'without', 'indexOf', 'shuffle', 'lastIndexOf',
+    'isEmpty', 'chain'];
+
+  // Mix in each Underscore method as a proxy to `Collection#models`.
+  _.each(methods, function(method) {
+    Collection.prototype[method] = function() {
+      var args = slice.call(arguments);
+      args.unshift(this.models);
+      return _[method].apply(_, args);
+    };
+  });
+
+  // Underscore methods that take a property name as an argument.
+  var attributeMethods = ['groupBy', 'countBy', 'sortBy'];
+
+  // Use attributes instead of properties.
+  _.each(attributeMethods, function(method) {
+    Collection.prototype[method] = function(value, context) {
+      var iterator = _.isFunction(value) ? value : function(model) {
+        return model.get(value);
+      };
+      return _[method](this.models, iterator, context);
+    };
+  });
+
+  // Backbone.Router
+  // ---------------
+
+  // Routers map faux-URLs to actions, and fire events when routes are
+  // matched. Creating a new one sets its `routes` hash, if not set statically.
+  var Router = Backbone.Router = function(options) {
+    options || (options = {});
+    if (options.routes) this.routes = options.routes;
+    this._bindRoutes();
+    this.initialize.apply(this, arguments);
+  };
+
+  // Cached regular expressions for matching named param parts and splatted
+  // parts of route strings.
+  var optionalParam = /\((.*?)\)/g;
+  var namedParam    = /(\(\?)?:\w+/g;
+  var splatParam    = /\*\w+/g;
+  var escapeRegExp  = /[\-{}\[\]+?.,\\\^$|#\s]/g;
+
+  // Set up all inheritable **Backbone.Router** properties and methods.
+  _.extend(Router.prototype, Events, {
+
+    // Initialize is an empty function by default. Override it with your own
+    // initialization logic.
+    initialize: function(){},
+
+    // Manually bind a single named route to a callback. For example:
+    //
+    //     this.route('search/:query/p:num', 'search', function(query, num) {
+    //       ...
+    //     });
+    //
+    route: function(route, name, callback) {
+      if (!_.isRegExp(route)) route = this._routeToRegExp(route);
+      if (!callback) callback = this[name];
+      Backbone.history.route(route, _.bind(function(fragment) {
+        var args = this._extractParameters(route, fragment);
+        callback && callback.apply(this, args);
+        this.trigger.apply(this, ['route:' + name].concat(args));
+        this.trigger('route', name, args);
+        Backbone.history.trigger('route', this, name, args);
+      }, this));
+      return this;
+    },
+
+    // Simple proxy to `Backbone.history` to save a fragment into the history.
+    navigate: function(fragment, options) {
+      Backbone.history.navigate(fragment, options);
+      return this;
+    },
+
+    // Bind all defined routes to `Backbone.history`. We have to reverse the
+    // order of the routes here to support behavior where the most general
+    // routes can be defined at the bottom of the route map.
+    _bindRoutes: function() {
+      if (!this.routes) return;
+      var route, routes = _.keys(this.routes);
+      while ((route = routes.pop()) != null) {
+        this.route(route, this.routes[route]);
+      }
+    },
+
+    // Convert a route string into a regular expression, suitable for matching
+    // against the current location hash.
+    _routeToRegExp: function(route) {
+      route = route.replace(escapeRegExp, '\\$&')
+                   .replace(optionalParam, '(?:$1)?')
+                   .replace(namedParam, function(match, optional){
+                     return optional ? match : '([^\/]+)';
+                   })
+                   .replace(splatParam, '(.*?)');
+      return new RegExp('^' + route + '$');
+    },
+
+    // Given a route, and a URL fragment that it matches, return the array of
+    // extracted parameters.
+    _extractParameters: function(route, fragment) {
+      return route.exec(fragment).slice(1);
+    }
+
+  });
+
+  // Backbone.History
+  // ----------------
+
+  // Handles cross-browser history management, based on URL fragments. If the
+  // browser does not support `onhashchange`, falls back to polling.
+  var History = Backbone.History = function() {
+    this.handlers = [];
+    _.bindAll(this, 'checkUrl');
+
+    // Ensure that `History` can be used outside of the browser.
+    if (typeof window !== 'undefined') {
+      this.location = window.location;
+      this.history = window.history;
+    }
+  };
+
+  // Cached regex for stripping a leading hash/slash and trailing space.
+  var routeStripper = /^[#\/]|\s+$/g;
+
+  // Cached regex for stripping leading and trailing slashes.
+  var rootStripper = /^\/+|\/+$/g;
+
+  // Cached regex for detecting MSIE.
+  var isExplorer = /msie [\w.]+/;
+
+  // Cached regex for removing a trailing slash.
+  var trailingSlash = /\/$/;
+
+  // Has the history handling already been started?
+  History.started = false;
+
+  // Set up all inheritable **Backbone.History** properties and methods.
+  _.extend(History.prototype, Events, {
+
+    // The default interval to poll for hash changes, if necessary, is
+    // twenty times a second.
+    interval: 50,
+
+    // Gets the true hash value. Cannot use location.hash directly due to bug
+    // in Firefox where location.hash will always be decoded.
+    getHash: function(window) {
+      var match = (window || this).location.href.match(/#(.*)$/);
+      return match ? match[1] : '';
+    },
+
+    // Get the cross-browser normalized URL fragment, either from the URL,
+    // the hash, or the override.
+    getFragment: function(fragment, forcePushState) {
+      if (fragment == null) {
+        if (this._hasPushState || !this._wantsHashChange || forcePushState) {
+          fragment = this.location.pathname;
+          var root = this.root.replace(trailingSlash, '');
+          if (!fragment.indexOf(root)) fragment = fragment.substr(root.length);
+        } else {
+          fragment = this.getHash();
+        }
+      }
+      return fragment.replace(routeStripper, '');
+    },
+
+    // Start the hash change handling, returning `true` if the current URL matches
+    // an existing route, and `false` otherwise.
+    start: function(options) {
+      if (History.started) throw new Error("Backbone.history has already been started");
+      History.started = true;
+
+      // Figure out the initial configuration. Do we need an iframe?
+      // Is pushState desired ... is it available?
+      this.options          = _.extend({}, {root: '/'}, this.options, options);
+      this.root             = this.options.root;
+      this._wantsHashChange = this.options.hashChange !== false;
+      this._wantsPushState  = !!this.options.pushState;
+      this._hasPushState    = !!(this.options.pushState && this.history && this.history.pushState);
+      var fragment          = this.getFragment();
+      var docMode           = document.documentMode;
+      var oldIE             = (isExplorer.exec(navigator.userAgent.toLowerCase()) && (!docMode || docMode <= 7));
+
+      // Normalize root to always include a leading and trailing slash.
+      this.root = ('/' + this.root + '/').replace(rootStripper, '/');
+
+      if (oldIE && this._wantsHashChange) {
+        this.iframe = Backbone.$('<iframe src="javascript:0" tabindex="-1" />').hide().appendTo('body')[0].contentWindow;
+        this.navigate(fragment);
+      }
+
+      // Depending on whether we're using pushState or hashes, and whether
+      // 'onhashchange' is supported, determine how we check the URL state.
+      if (this._hasPushState) {
+        Backbone.$(window).on('popstate', this.checkUrl);
+      } else if (this._wantsHashChange && ('onhashchange' in window) && !oldIE) {
+        Backbone.$(window).on('hashchange', this.checkUrl);
+      } else if (this._wantsHashChange) {
+        this._checkUrlInterval = setInterval(this.checkUrl, this.interval);
+      }
+
+      // Determine if we need to change the base url, for a pushState link
+      // opened by a non-pushState browser.
+      this.fragment = fragment;
+      var loc = this.location;
+      var atRoot = loc.pathname.replace(/[^\/]$/, '$&/') === this.root;
+
+      // If we've started off with a route from a `pushState`-enabled browser,
+      // but we're currently in a browser that doesn't support it...
+      if (this._wantsHashChange && this._wantsPushState && !this._hasPushState && !atRoot) {
+        this.fragment = this.getFragment(null, true);
+        this.location.replace(this.root + this.location.search + '#' + this.fragment);
+        // Return immediately as browser will do redirect to new url
+        return true;
+
+      // Or if we've started out with a hash-based route, but we're currently
+      // in a browser where it could be `pushState`-based instead...
+      } else if (this._wantsPushState && this._hasPushState && atRoot && loc.hash) {
+        this.fragment = this.getHash().replace(routeStripper, '');
+        this.history.replaceState({}, document.title, this.root + this.fragment + loc.search);
+      }
+
+      if (!this.options.silent) return this.loadUrl();
+    },
+
+    // Disable Backbone.history, perhaps temporarily. Not useful in a real app,
+    // but possibly useful for unit testing Routers.
+    stop: function() {
+      Backbone.$(window).off('popstate', this.checkUrl).off('hashchange', this.checkUrl);
+      clearInterval(this._checkUrlInterval);
+      History.started = false;
+    },
+
+    // Add a route to be tested when the fragment changes. Routes added later
+    // may override previous routes.
+    route: function(route, callback) {
+      this.handlers.unshift({route: route, callback: callback});
+    },
+
+    // Checks the current URL to see if it has changed, and if it has,
+    // calls `loadUrl`, normalizing across the hidden iframe.
+    checkUrl: function(e) {
+      var current = this.getFragment();
+      if (current === this.fragment && this.iframe) {
+        current = this.getFragment(this.getHash(this.iframe));
+      }
+      if (current === this.fragment) return false;
+      if (this.iframe) this.navigate(current);
+      this.loadUrl() || this.loadUrl(this.getHash());
+    },
+
+    // Attempt to load the current URL fragment. If a route succeeds with a
+    // match, returns `true`. If no defined routes matches the fragment,
+    // returns `false`.
+    loadUrl: function(fragmentOverride) {
+      var fragment = this.fragment = this.getFragment(fragmentOverride);
+      var matched = _.any(this.handlers, function(handler) {
+        if (handler.route.test(fragment)) {
+          handler.callback(fragment);
+          return true;
+        }
+      });
+      return matched;
+    },
+
+    // Save a fragment into the hash history, or replace the URL state if the
+    // 'replace' option is passed. You are responsible for properly URL-encoding
+    // the fragment in advance.
+    //
+    // The options object can contain `trigger: true` if you wish to have the
+    // route callback be fired (not usually desirable), or `replace: true`, if
+    // you wish to modify the current URL without adding an entry to the history.
+    navigate: function(fragment, options) {
+      if (!History.started) return false;
+      if (!options || options === true) options = {trigger: options};
+      fragment = this.getFragment(fragment || '');
+      if (this.fragment === fragment) return;
+      this.fragment = fragment;
+      var url = this.root + fragment;
+
+      // If pushState is available, we use it to set the fragment as a real URL.
+      if (this._hasPushState) {
+        this.history[options.replace ? 'replaceState' : 'pushState']({}, document.title, url);
+
+      // If hash changes haven't been explicitly disabled, update the hash
+      // fragment to store history.
+      } else if (this._wantsHashChange) {
+        this._updateHash(this.location, fragment, options.replace);
+        if (this.iframe && (fragment !== this.getFragment(this.getHash(this.iframe)))) {
+          // Opening and closing the iframe tricks IE7 and earlier to push a
+          // history entry on hash-tag change.  When replace is true, we don't
+          // want this.
+          if(!options.replace) this.iframe.document.open().close();
+          this._updateHash(this.iframe.location, fragment, options.replace);
+        }
+
+      // If you've told us that you explicitly don't want fallback hashchange-
+      // based history, then `navigate` becomes a page refresh.
+      } else {
+        return this.location.assign(url);
+      }
+      if (options.trigger) this.loadUrl(fragment);
+    },
+
+    // Update the hash location, either replacing the current entry, or adding
+    // a new one to the browser history.
+    _updateHash: function(location, fragment, replace) {
+      if (replace) {
+        var href = location.href.replace(/(javascript:|#).*$/, '');
+        location.replace(href + '#' + fragment);
+      } else {
+        // Some browsers require that `hash` contains a leading #.
+        location.hash = '#' + fragment;
+      }
+    }
+
+  });
+
+  // Create the default Backbone.history.
+  Backbone.history = new History;
+
+  // Backbone.View
+  // -------------
+
+  // Creating a Backbone.View creates its initial element outside of the DOM,
+  // if an existing element is not provided...
+  var View = Backbone.View = function(options) {
+    this.cid = _.uniqueId('view');
+    this._configure(options || {});
+    this._ensureElement();
+    this.initialize.apply(this, arguments);
+    this.delegateEvents();
+  };
+
+  // Cached regex to split keys for `delegate`.
+  var delegateEventSplitter = /^(\S+)\s*(.*)$/;
+
+  // List of view options to be merged as properties.
+  var viewOptions = ['model', 'collection', 'el', 'id', 'attributes', 'className', 'tagName', 'events'];
+
+  // Set up all inheritable **Backbone.View** properties and methods.
+  _.extend(View.prototype, Events, {
+
+    // The default `tagName` of a View's element is `"div"`.
+    tagName: 'div',
+
+    // jQuery delegate for element lookup, scoped to DOM elements within the
+    // current view. This should be prefered to global lookups where possible.
+    $: function(selector) {
+      return this.$el.find(selector);
+    },
+
+    // Initialize is an empty function by default. Override it with your own
+    // initialization logic.
+    initialize: function(){},
+
+    // **render** is the core function that your view should override, in order
+    // to populate its element (`this.el`), with the appropriate HTML. The
+    // convention is for **render** to always return `this`.
+    render: function() {
+      return this;
+    },
+
+    // Remove this view by taking the element out of the DOM, and removing any
+    // applicable Backbone.Events listeners.
+    remove: function() {
+      this.$el.remove();
+      this.stopListening();
+      return this;
+    },
+
+    // Change the view's element (`this.el` property), including event
+    // re-delegation.
+    setElement: function(element, delegate) {
+      if (this.$el) this.undelegateEvents();
+      this.$el = element instanceof Backbone.$ ? element : Backbone.$(element);
+      this.el = this.$el[0];
+      if (delegate !== false) this.delegateEvents();
+      return this;
+    },
+
+    // Set callbacks, where `this.events` is a hash of
+    //
+    // *{"event selector": "callback"}*
+    //
+    //     {
+    //       'mousedown .title':  'edit',
+    //       'click .button':     'save'
+    //       'click .open':       function(e) { ... }
+    //     }
+    //
+    // pairs. Callbacks will be bound to the view, with `this` set properly.
+    // Uses event delegation for efficiency.
+    // Omitting the selector binds the event to `this.el`.
+    // This only works for delegate-able events: not `focus`, `blur`, and
+    // not `change`, `submit`, and `reset` in Internet Explorer.
+    delegateEvents: function(events) {
+      if (!(events || (events = _.result(this, 'events')))) return;
+      this.undelegateEvents();
+      for (var key in events) {
+        var method = events[key];
+        if (!_.isFunction(method)) method = this[events[key]];
+        if (!method) throw new Error('Method "' + events[key] + '" does not exist');
+        var match = key.match(delegateEventSplitter);
+        var eventName = match[1], selector = match[2];
+        method = _.bind(method, this);
+        eventName += '.delegateEvents' + this.cid;
+        if (selector === '') {
+          this.$el.on(eventName, method);
+        } else {
+          this.$el.on(eventName, selector, method);
+        }
+      }
+    },
+
+    // Clears all callbacks previously bound to the view with `delegateEvents`.
+    // You usually don't need to use this, but may wish to if you have multiple
+    // Backbone views attached to the same DOM element.
+    undelegateEvents: function() {
+      this.$el.off('.delegateEvents' + this.cid);
+    },
+
+    // Performs the initial configuration of a View with a set of options.
+    // Keys with special meaning *(model, collection, id, className)*, are
+    // attached directly to the view.
+    _configure: function(options) {
+      if (this.options) options = _.extend({}, _.result(this, 'options'), options);
+      _.extend(this, _.pick(options, viewOptions));
+      this.options = options;
+    },
+
+    // Ensure that the View has a DOM element to render into.
+    // If `this.el` is a string, pass it through `$()`, take the first
+    // matching element, and re-assign it to `el`. Otherwise, create
+    // an element from the `id`, `className` and `tagName` properties.
+    _ensureElement: function() {
+      if (!this.el) {
+        var attrs = _.extend({}, _.result(this, 'attributes'));
+        if (this.id) attrs.id = _.result(this, 'id');
+        if (this.className) attrs['class'] = _.result(this, 'className');
+        var $el = Backbone.$('<' + _.result(this, 'tagName') + '>').attr(attrs);
+        this.setElement($el, false);
+      } else {
+        this.setElement(_.result(this, 'el'), false);
+      }
+    }
+
+  });
+
+  // Backbone.sync
+  // -------------
+
+  // Map from CRUD to HTTP for our default `Backbone.sync` implementation.
+  var methodMap = {
+    'create': 'POST',
+    'update': 'PUT',
+    'patch':  'PATCH',
+    'delete': 'DELETE',
+    'read':   'GET'
+  };
+
+  // Override this function to change the manner in which Backbone persists
+  // models to the server. You will be passed the type of request, and the
+  // model in question. By default, makes a RESTful Ajax request
+  // to the model's `url()`. Some possible customizations could be:
+  //
+  // * Use `setTimeout` to batch rapid-fire updates into a single request.
+  // * Send up the models as XML instead of JSON.
+  // * Persist models via WebSockets instead of Ajax.
+  //
+  // Turn on `Backbone.emulateHTTP` in order to send `PUT` and `DELETE` requests
+  // as `POST`, with a `_method` parameter containing the true HTTP method,
+  // as well as all requests with the body as `application/x-www-form-urlencoded`
+  // instead of `application/json` with the model in a param named `model`.
+  // Useful when interfacing with server-side languages like **PHP** that make
+  // it difficult to read the body of `PUT` requests.
+  Backbone.sync = function(method, model, options) {
+    var type = methodMap[method];
+
+    // Default options, unless specified.
+    _.defaults(options || (options = {}), {
+      emulateHTTP: Backbone.emulateHTTP,
+      emulateJSON: Backbone.emulateJSON
+    });
+
+    // Default JSON-request options.
+    var params = {type: type, dataType: 'json'};
+
+    // Ensure that we have a URL.
+    if (!options.url) {
+      params.url = _.result(model, 'url') || urlError();
+    }
+
+    // Ensure that we have the appropriate request data.
+    if (options.data == null && model && (method === 'create' || method === 'update' || method === 'patch')) {
+      params.contentType = 'application/json';
+      params.data = JSON.stringify(options.attrs || model.toJSON(options));
+    }
+
+    // For older servers, emulate JSON by encoding the request into an HTML-form.
+    if (options.emulateJSON) {
+      params.contentType = 'application/x-www-form-urlencoded';
+      params.data = params.data ? {model: params.data} : {};
+    }
+
+    // For older servers, emulate HTTP by mimicking the HTTP method with `_method`
+    // And an `X-HTTP-Method-Override` header.
+    if (options.emulateHTTP && (type === 'PUT' || type === 'DELETE' || type === 'PATCH')) {
+      params.type = 'POST';
+      if (options.emulateJSON) params.data._method = type;
+      var beforeSend = options.beforeSend;
+      options.beforeSend = function(xhr) {
+        xhr.setRequestHeader('X-HTTP-Method-Override', type);
+        if (beforeSend) return beforeSend.apply(this, arguments);
+      };
+    }
+
+    // Don't process data on a non-GET request.
+    if (params.type !== 'GET' && !options.emulateJSON) {
+      params.processData = false;
+    }
+
+    var success = options.success;
+    options.success = function(resp) {
+      if (success) success(model, resp, options);
+      model.trigger('sync', model, resp, options);
+    };
+
+    var error = options.error;
+    options.error = function(xhr) {
+      if (error) error(model, xhr, options);
+      model.trigger('error', model, xhr, options);
+    };
+
+    // Make the request, allowing the user to override any Ajax options.
+    var xhr = options.xhr = Backbone.ajax(_.extend(params, options));
+    model.trigger('request', model, xhr, options);
+    return xhr;
+  };
+
+  // Set the default implementation of `Backbone.ajax` to proxy through to `$`.
+  Backbone.ajax = function() {
+    return Backbone.$.ajax.apply(Backbone.$, arguments);
+  };
+
+  // Helpers
+  // -------
+
+  // Helper function to correctly set up the prototype chain, for subclasses.
+  // Similar to `goog.inherits`, but uses a hash of prototype properties and
+  // class properties to be extended.
+  var extend = function(protoProps, staticProps) {
+    var parent = this;
+    var child;
+
+    // The constructor function for the new subclass is either defined by you
+    // (the "constructor" property in your `extend` definition), or defaulted
+    // by us to simply call the parent's constructor.
+    if (protoProps && _.has(protoProps, 'constructor')) {
+      child = protoProps.constructor;
+    } else {
+      child = function(){ return parent.apply(this, arguments); };
+    }
+
+    // Add static properties to the constructor function, if supplied.
+    _.extend(child, parent, staticProps);
+
+    // Set the prototype chain to inherit from `parent`, without calling
+    // `parent`'s constructor function.
+    var Surrogate = function(){ this.constructor = child; };
+    Surrogate.prototype = parent.prototype;
+    child.prototype = new Surrogate;
+
+    // Add prototype properties (instance properties) to the subclass,
+    // if supplied.
+    if (protoProps) _.extend(child.prototype, protoProps);
+
+    // Set a convenience property in case the parent's prototype is needed
+    // later.
+    child.__super__ = parent.prototype;
+
+    return child;
+  };
+
+  // Set up inheritance for the model, collection, router, view and history.
+  Model.extend = Collection.extend = Router.extend = View.extend = History.extend = extend;
+
+  // Throw an error when a URL is needed, and none is supplied.
+  var urlError = function() {
+    throw new Error('A "url" property or function must be specified');
+  };
+
+}).call(this);
diff --git a/module/web/static/js/libs/backbone.wreqr-0.1.0.js b/module/web/static/js/libs/backbone.wreqr-0.1.0.js
new file mode 100644
index 000000000..d1526c76b
--- /dev/null
+++ b/module/web/static/js/libs/backbone.wreqr-0.1.0.js
@@ -0,0 +1,150 @@
+// Backbone.Wreqr, v0.1.0
+// Copyright (c)2012 Derick Bailey, Muted Solutions, LLC.
+// Distributed under MIT license
+// http://github.com/marionettejs/backbone.wreqr
+(function (root, factory) {
+  if (typeof exports === 'object') {
+
+    var underscore = require('underscore');
+    var backbone = require('backbone');
+
+    module.exports = factory(underscore, backbone);
+
+  } else if (typeof define === 'function' && define.amd) {
+
+    define(['underscore', 'backbone'], factory);
+
+  } 
+}(this, function (_, Backbone) {
+  "option strict";
+
+  Backbone.Wreqr = (function(Backbone, Marionette, _){
+    "option strict";
+    var Wreqr = {};
+  
+    // Handlers
+    // --------
+    // A registry of functions to call, given a name
+    
+    Wreqr.Handlers = (function(Backbone, _){
+      "option strict";
+      
+      // Constructor
+      // -----------
+    
+      var Handlers = function(){
+        "use strict";
+        this._handlers = {};
+      };
+    
+      Handlers.extend = Backbone.Model.extend;
+    
+      // Instance Members
+      // ----------------
+    
+      _.extend(Handlers.prototype, {
+    
+        // Add a handler for the given name, with an
+        // optional context to run the handler within
+        addHandler: function(name, handler, context){
+          var config = {
+            callback: handler,
+            context: context
+          };
+    
+          this._handlers[name] = config;
+        },
+    
+        // Get the currently registered handler for
+        // the specified name. Throws an exception if
+        // no handler is found.
+        getHandler: function(name){
+          var config = this._handlers[name];
+    
+          if (!config){
+            throw new Error("Handler not found for '" + name + "'");
+          }
+    
+          return function(){
+            var args = Array.prototype.slice.apply(arguments);
+            return config.callback.apply(config.context, args);
+          };
+        },
+    
+        // Remove a handler for the specified name
+        removeHandler: function(name){
+          delete this._handlers[name];
+        },
+    
+        // Remove all handlers from this registry
+        removeAllHandlers: function(){
+          this._handlers = {};
+        }
+      });
+    
+      return Handlers;
+    })(Backbone, _);
+    
+    // Wreqr.Commands
+    // --------------
+    //
+    // A simple command pattern implementation. Register a command
+    // handler and execute it.
+    Wreqr.Commands = (function(Wreqr){
+      "option strict";
+    
+      return Wreqr.Handlers.extend({
+        execute: function(){
+          var name = arguments[0];
+          var args = Array.prototype.slice.call(arguments, 1);
+    
+          this.getHandler(name).apply(this, args);
+        }
+      });
+    
+    })(Wreqr);
+    
+    // Wreqr.RequestResponse
+    // ---------------------
+    //
+    // A simple request/response implementation. Register a
+    // request handler, and return a response from it
+    Wreqr.RequestResponse = (function(Wreqr){
+      "option strict";
+    
+      return Wreqr.Handlers.extend({
+        request: function(){
+          var name = arguments[0];
+          var args = Array.prototype.slice.call(arguments, 1);
+    
+          return this.getHandler(name).apply(this, args);
+        }
+      });
+    
+    })(Wreqr);
+    
+    // Event Aggregator
+    // ----------------
+    // A pub-sub object that can be used to decouple various parts
+    // of an application through event-driven architecture.
+    
+    Wreqr.EventAggregator = (function(Backbone, _){
+      "option strict";
+      var EA = function(){};
+    
+      // Copy the `extend` function used by Backbone's classes
+      EA.extend = Backbone.Model.extend;
+    
+      // Copy the basic Backbone.Events on to the event aggregator
+      _.extend(EA.prototype, Backbone.Events);
+    
+      return EA;
+    })(Backbone, _);
+    
+  
+    return Wreqr;
+  })(Backbone, Backbone.Marionette, _);
+  
+  return Backbone.Wreqr; 
+
+}));
diff --git a/module/web/static/js/libs/bootstrap-2.3.js b/module/web/static/js/libs/bootstrap-2.3.js
new file mode 100755
index 000000000..09b812c4f
--- /dev/null
+++ b/module/web/static/js/libs/bootstrap-2.3.js
@@ -0,0 +1,2279 @@
+/* ===================================================
+ * bootstrap-transition.js v2.3.0
+ * http://twitter.github.com/bootstrap/javascript.html#transitions
+ * ===================================================
+ * Copyright 2012 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ========================================================== */
+
+
+!function ($) {
+
+  "use strict"; // jshint ;_;
+
+
+  /* CSS TRANSITION SUPPORT (http://www.modernizr.com/)
+   * ======================================================= */
+
+  $(function () {
+
+    $.support.transition = (function () {
+
+      var transitionEnd = (function () {
+
+        var el = document.createElement('bootstrap')
+          , transEndEventNames = {
+               'WebkitTransition' : 'webkitTransitionEnd'
+            ,  'MozTransition'    : 'transitionend'
+            ,  'OTransition'      : 'oTransitionEnd otransitionend'
+            ,  'transition'       : 'transitionend'
+            }
+          , name
+
+        for (name in transEndEventNames){
+          if (el.style[name] !== undefined) {
+            return transEndEventNames[name]
+          }
+        }
+
+      }())
+
+      return transitionEnd && {
+        end: transitionEnd
+      }
+
+    })()
+
+  })
+
+}(window.jQuery);
+/* =========================================================
+ * bootstrap-modal.js v2.3.0
+ * http://twitter.github.com/bootstrap/javascript.html#modals
+ * =========================================================
+ * Copyright 2012 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ========================================================= */
+
+
+!function ($) {
+
+  "use strict"; // jshint ;_;
+
+
+ /* MODAL CLASS DEFINITION
+  * ====================== */
+
+  var Modal = function (element, options) {
+    this.options = options
+    this.$element = $(element)
+      .delegate('[data-dismiss="modal"]', 'click.dismiss.modal', $.proxy(this.hide, this))
+    this.options.remote && this.$element.find('.modal-body').load(this.options.remote)
+  }
+
+  Modal.prototype = {
+
+      constructor: Modal
+
+    , toggle: function () {
+        return this[!this.isShown ? 'show' : 'hide']()
+      }
+
+    , show: function () {
+        var that = this
+          , e = $.Event('show')
+
+        this.$element.trigger(e)
+
+        if (this.isShown || e.isDefaultPrevented()) return
+
+        this.isShown = true
+
+        this.escape()
+
+        this.backdrop(function () {
+          var transition = $.support.transition && that.$element.hasClass('fade')
+
+          if (!that.$element.parent().length) {
+            that.$element.appendTo(document.body) //don't move modals dom position
+          }
+
+          that.$element.show()
+
+          if (transition) {
+            that.$element[0].offsetWidth // force reflow
+          }
+
+          that.$element
+            .addClass('in')
+            .attr('aria-hidden', false)
+
+          that.enforceFocus()
+
+          transition ?
+            that.$element.one($.support.transition.end, function () { that.$element.focus().trigger('shown') }) :
+            that.$element.focus().trigger('shown')
+
+        })
+      }
+
+    , hide: function (e) {
+        e && e.preventDefault()
+
+        var that = this
+
+        e = $.Event('hide')
+
+        this.$element.trigger(e)
+
+        if (!this.isShown || e.isDefaultPrevented()) return
+
+        this.isShown = false
+
+        this.escape()
+
+        $(document).off('focusin.modal')
+
+        this.$element
+          .removeClass('in')
+          .attr('aria-hidden', true)
+
+        $.support.transition && this.$element.hasClass('fade') ?
+          this.hideWithTransition() :
+          this.hideModal()
+      }
+
+    , enforceFocus: function () {
+        var that = this
+        $(document).on('focusin.modal', function (e) {
+          if (that.$element[0] !== e.target && !that.$element.has(e.target).length) {
+            that.$element.focus()
+          }
+        })
+      }
+
+    , escape: function () {
+        var that = this
+        if (this.isShown && this.options.keyboard) {
+          this.$element.on('keyup.dismiss.modal', function ( e ) {
+            e.which == 27 && that.hide()
+          })
+        } else if (!this.isShown) {
+          this.$element.off('keyup.dismiss.modal')
+        }
+      }
+
+    , hideWithTransition: function () {
+        var that = this
+          , timeout = setTimeout(function () {
+              that.$element.off($.support.transition.end)
+              that.hideModal()
+            }, 500)
+
+        this.$element.one($.support.transition.end, function () {
+          clearTimeout(timeout)
+          that.hideModal()
+        })
+      }
+
+    , hideModal: function () {
+        var that = this
+        this.$element.hide()
+        this.backdrop(function () {
+          that.removeBackdrop()
+          that.$element.trigger('hidden')
+        })
+      }
+
+    , removeBackdrop: function () {
+        this.$backdrop.remove()
+        this.$backdrop = null
+      }
+
+    , backdrop: function (callback) {
+        var that = this
+          , animate = this.$element.hasClass('fade') ? 'fade' : ''
+
+        if (this.isShown && this.options.backdrop) {
+          var doAnimate = $.support.transition && animate
+
+          this.$backdrop = $('<div class="modal-backdrop ' + animate + '" />')
+            .appendTo(document.body)
+
+          this.$backdrop.click(
+            this.options.backdrop == 'static' ?
+              $.proxy(this.$element[0].focus, this.$element[0])
+            : $.proxy(this.hide, this)
+          )
+
+          if (doAnimate) this.$backdrop[0].offsetWidth // force reflow
+
+          this.$backdrop.addClass('in')
+
+          if (!callback) return
+
+          doAnimate ?
+            this.$backdrop.one($.support.transition.end, callback) :
+            callback()
+
+        } else if (!this.isShown && this.$backdrop) {
+          this.$backdrop.removeClass('in')
+
+          $.support.transition && this.$element.hasClass('fade')?
+            this.$backdrop.one($.support.transition.end, callback) :
+            callback()
+
+        } else if (callback) {
+          callback()
+        }
+      }
+  }
+
+
+ /* MODAL PLUGIN DEFINITION
+  * ======================= */
+
+  var old = $.fn.modal
+
+  $.fn.modal = function (option) {
+    return this.each(function () {
+      var $this = $(this)
+        , data = $this.data('modal')
+        , options = $.extend({}, $.fn.modal.defaults, $this.data(), typeof option == 'object' && option)
+      if (!data) $this.data('modal', (data = new Modal(this, options)))
+      if (typeof option == 'string') data[option]()
+      else if (options.show) data.show()
+    })
+  }
+
+  $.fn.modal.defaults = {
+      backdrop: true
+    , keyboard: true
+    , show: true
+  }
+
+  $.fn.modal.Constructor = Modal
+
+
+ /* MODAL NO CONFLICT
+  * ================= */
+
+  $.fn.modal.noConflict = function () {
+    $.fn.modal = old
+    return this
+  }
+
+
+ /* MODAL DATA-API
+  * ============== */
+
+  $(document).on('click.modal.data-api', '[data-toggle="modal"]', function (e) {
+    var $this = $(this)
+      , href = $this.attr('href')
+      , $target = $($this.attr('data-target') || (href && href.replace(/.*(?=#[^\s]+$)/, ''))) //strip for ie7
+      , option = $target.data('modal') ? 'toggle' : $.extend({ remote:!/#/.test(href) && href }, $target.data(), $this.data())
+
+    e.preventDefault()
+
+    $target
+      .modal(option)
+      .one('hide', function () {
+        $this.focus()
+      })
+  })
+
+}(window.jQuery);
+
+/* ============================================================
+ * bootstrap-dropdown.js v2.3.0
+ * http://twitter.github.com/bootstrap/javascript.html#dropdowns
+ * ============================================================
+ * Copyright 2012 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============================================================ */
+
+
+!function ($) {
+
+  "use strict"; // jshint ;_;
+
+
+ /* DROPDOWN CLASS DEFINITION
+  * ========================= */
+
+  var toggle = '[data-toggle=dropdown]'
+    , Dropdown = function (element) {
+        var $el = $(element).on('click.dropdown.data-api', this.toggle)
+        $('html').on('click.dropdown.data-api', function () {
+          $el.parent().removeClass('open')
+        })
+      }
+
+  Dropdown.prototype = {
+
+    constructor: Dropdown
+
+  , toggle: function (e) {
+      var $this = $(this)
+        , $parent
+        , isActive
+
+      if ($this.is('.disabled, :disabled')) return
+
+      $parent = getParent($this)
+
+      isActive = $parent.hasClass('open')
+
+      clearMenus()
+
+      if (!isActive) {
+        $parent.toggleClass('open')
+      }
+
+      $this.focus()
+
+      return false
+    }
+
+  , keydown: function (e) {
+      var $this
+        , $items
+        , $active
+        , $parent
+        , isActive
+        , index
+
+      if (!/(38|40|27)/.test(e.keyCode)) return
+
+      $this = $(this)
+
+      e.preventDefault()
+      e.stopPropagation()
+
+      if ($this.is('.disabled, :disabled')) return
+
+      $parent = getParent($this)
+
+      isActive = $parent.hasClass('open')
+
+      if (!isActive || (isActive && e.keyCode == 27)) {
+        if (e.which == 27) $parent.find(toggle).focus()
+        return $this.click()
+      }
+
+      $items = $('[role=menu] li:not(.divider):visible a', $parent)
+
+      if (!$items.length) return
+
+      index = $items.index($items.filter(':focus'))
+
+      if (e.keyCode == 38 && index > 0) index--                                        // up
+      if (e.keyCode == 40 && index < $items.length - 1) index++                        // down
+      if (!~index) index = 0
+
+      $items
+        .eq(index)
+        .focus()
+    }
+
+  }
+
+  function clearMenus() {
+    $(toggle).each(function () {
+      getParent($(this)).removeClass('open')
+    })
+  }
+
+  function getParent($this) {
+    var selector = $this.attr('data-target')
+      , $parent
+
+    if (!selector) {
+      selector = $this.attr('href')
+      selector = selector && /#/.test(selector) && selector.replace(/.*(?=#[^\s]*$)/, '') //strip for ie7
+    }
+
+    $parent = selector && $(selector)
+
+    if (!$parent || !$parent.length) $parent = $this.parent()
+
+    return $parent
+  }
+
+
+  /* DROPDOWN PLUGIN DEFINITION
+   * ========================== */
+
+  var old = $.fn.dropdown
+
+  $.fn.dropdown = function (option) {
+    return this.each(function () {
+      var $this = $(this)
+        , data = $this.data('dropdown')
+      if (!data) $this.data('dropdown', (data = new Dropdown(this)))
+      if (typeof option == 'string') data[option].call($this)
+    })
+  }
+
+  $.fn.dropdown.Constructor = Dropdown
+
+
+ /* DROPDOWN NO CONFLICT
+  * ==================== */
+
+  $.fn.dropdown.noConflict = function () {
+    $.fn.dropdown = old
+    return this
+  }
+
+
+  /* APPLY TO STANDARD DROPDOWN ELEMENTS
+   * =================================== */
+
+  $(document)
+    .on('click.dropdown.data-api', clearMenus)
+    .on('click.dropdown.data-api', '.dropdown form', function (e) { e.stopPropagation() })
+    .on('.dropdown-menu', function (e) { e.stopPropagation() })
+    .on('click.dropdown.data-api'  , toggle, Dropdown.prototype.toggle)
+    .on('keydown.dropdown.data-api', toggle + ', [role=menu]' , Dropdown.prototype.keydown)
+
+}(window.jQuery);
+
+/* =============================================================
+ * bootstrap-scrollspy.js v2.3.0
+ * http://twitter.github.com/bootstrap/javascript.html#scrollspy
+ * =============================================================
+ * Copyright 2012 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============================================================== */
+
+
+!function ($) {
+
+  "use strict"; // jshint ;_;
+
+
+ /* SCROLLSPY CLASS DEFINITION
+  * ========================== */
+
+  function ScrollSpy(element, options) {
+    var process = $.proxy(this.process, this)
+      , $element = $(element).is('body') ? $(window) : $(element)
+      , href
+    this.options = $.extend({}, $.fn.scrollspy.defaults, options)
+    this.$scrollElement = $element.on('scroll.scroll-spy.data-api', process)
+    this.selector = (this.options.target
+      || ((href = $(element).attr('href')) && href.replace(/.*(?=#[^\s]+$)/, '')) //strip for ie7
+      || '') + ' .nav li > a'
+    this.$body = $('body')
+    this.refresh()
+    this.process()
+  }
+
+  ScrollSpy.prototype = {
+
+      constructor: ScrollSpy
+
+    , refresh: function () {
+        var self = this
+          , $targets
+
+        this.offsets = $([])
+        this.targets = $([])
+
+        $targets = this.$body
+          .find(this.selector)
+          .map(function () {
+            var $el = $(this)
+              , href = $el.data('target') || $el.attr('href')
+              , $href = /^#\w/.test(href) && $(href)
+            return ( $href
+              && $href.length
+              && [[ $href.position().top + (!$.isWindow(self.$scrollElement.get(0)) && self.$scrollElement.scrollTop()), href ]] ) || null
+          })
+          .sort(function (a, b) { return a[0] - b[0] })
+          .each(function () {
+            self.offsets.push(this[0])
+            self.targets.push(this[1])
+          })
+      }
+
+    , process: function () {
+        var scrollTop = this.$scrollElement.scrollTop() + this.options.offset
+          , scrollHeight = this.$scrollElement[0].scrollHeight || this.$body[0].scrollHeight
+          , maxScroll = scrollHeight - this.$scrollElement.height()
+          , offsets = this.offsets
+          , targets = this.targets
+          , activeTarget = this.activeTarget
+          , i
+
+        if (scrollTop >= maxScroll) {
+          return activeTarget != (i = targets.last()[0])
+            && this.activate ( i )
+        }
+
+        for (i = offsets.length; i--;) {
+          activeTarget != targets[i]
+            && scrollTop >= offsets[i]
+            && (!offsets[i + 1] || scrollTop <= offsets[i + 1])
+            && this.activate( targets[i] )
+        }
+      }
+
+    , activate: function (target) {
+        var active
+          , selector
+
+        this.activeTarget = target
+
+        $(this.selector)
+          .parent('.active')
+          .removeClass('active')
+
+        selector = this.selector
+          + '[data-target="' + target + '"],'
+          + this.selector + '[href="' + target + '"]'
+
+        active = $(selector)
+          .parent('li')
+          .addClass('active')
+
+        if (active.parent('.dropdown-menu').length)  {
+          active = active.closest('li.dropdown').addClass('active')
+        }
+
+        active.trigger('activate')
+      }
+
+  }
+
+
+ /* SCROLLSPY PLUGIN DEFINITION
+  * =========================== */
+
+  var old = $.fn.scrollspy
+
+  $.fn.scrollspy = function (option) {
+    return this.each(function () {
+      var $this = $(this)
+        , data = $this.data('scrollspy')
+        , options = typeof option == 'object' && option
+      if (!data) $this.data('scrollspy', (data = new ScrollSpy(this, options)))
+      if (typeof option == 'string') data[option]()
+    })
+  }
+
+  $.fn.scrollspy.Constructor = ScrollSpy
+
+  $.fn.scrollspy.defaults = {
+    offset: 10
+  }
+
+
+ /* SCROLLSPY NO CONFLICT
+  * ===================== */
+
+  $.fn.scrollspy.noConflict = function () {
+    $.fn.scrollspy = old
+    return this
+  }
+
+
+ /* SCROLLSPY DATA-API
+  * ================== */
+
+  $(window).on('load', function () {
+    $('[data-spy="scroll"]').each(function () {
+      var $spy = $(this)
+      $spy.scrollspy($spy.data())
+    })
+  })
+
+}(window.jQuery);
+/* ========================================================
+ * bootstrap-tab.js v2.3.0
+ * http://twitter.github.com/bootstrap/javascript.html#tabs
+ * ========================================================
+ * Copyright 2012 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ======================================================== */
+
+
+!function ($) {
+
+  "use strict"; // jshint ;_;
+
+
+ /* TAB CLASS DEFINITION
+  * ==================== */
+
+  var Tab = function (element) {
+    this.element = $(element)
+  }
+
+  Tab.prototype = {
+
+    constructor: Tab
+
+  , show: function () {
+      var $this = this.element
+        , $ul = $this.closest('ul:not(.dropdown-menu)')
+        , selector = $this.attr('data-target')
+        , previous
+        , $target
+        , e
+
+      if (!selector) {
+        selector = $this.attr('href')
+        selector = selector && selector.replace(/.*(?=#[^\s]*$)/, '') //strip for ie7
+      }
+
+      if ( $this.parent('li').hasClass('active') ) return
+
+      previous = $ul.find('.active:last a')[0]
+
+      e = $.Event('show', {
+        relatedTarget: previous
+      })
+
+      $this.trigger(e)
+
+      if (e.isDefaultPrevented()) return
+
+      $target = $(selector)
+
+      this.activate($this.parent('li'), $ul)
+      this.activate($target, $target.parent(), function () {
+        $this.trigger({
+          type: 'shown'
+        , relatedTarget: previous
+        })
+      })
+    }
+
+  , activate: function ( element, container, callback) {
+      var $active = container.find('> .active')
+        , transition = callback
+            && $.support.transition
+            && $active.hasClass('fade')
+
+      function next() {
+        $active
+          .removeClass('active')
+          .find('> .dropdown-menu > .active')
+          .removeClass('active')
+
+        element.addClass('active')
+
+        if (transition) {
+          element[0].offsetWidth // reflow for transition
+          element.addClass('in')
+        } else {
+          element.removeClass('fade')
+        }
+
+        if ( element.parent('.dropdown-menu') ) {
+          element.closest('li.dropdown').addClass('active')
+        }
+
+        callback && callback()
+      }
+
+      transition ?
+        $active.one($.support.transition.end, next) :
+        next()
+
+      $active.removeClass('in')
+    }
+  }
+
+
+ /* TAB PLUGIN DEFINITION
+  * ===================== */
+
+  var old = $.fn.tab
+
+  $.fn.tab = function ( option ) {
+    return this.each(function () {
+      var $this = $(this)
+        , data = $this.data('tab')
+      if (!data) $this.data('tab', (data = new Tab(this)))
+      if (typeof option == 'string') data[option]()
+    })
+  }
+
+  $.fn.tab.Constructor = Tab
+
+
+ /* TAB NO CONFLICT
+  * =============== */
+
+  $.fn.tab.noConflict = function () {
+    $.fn.tab = old
+    return this
+  }
+
+
+ /* TAB DATA-API
+  * ============ */
+
+  $(document).on('click.tab.data-api', '[data-toggle="tab"], [data-toggle="pill"]', function (e) {
+    e.preventDefault()
+    $(this).tab('show')
+  })
+
+}(window.jQuery);
+/* ===========================================================
+ * bootstrap-tooltip.js v2.3.0
+ * http://twitter.github.com/bootstrap/javascript.html#tooltips
+ * Inspired by the original jQuery.tipsy by Jason Frame
+ * ===========================================================
+ * Copyright 2012 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ========================================================== */
+
+
+!function ($) {
+
+  "use strict"; // jshint ;_;
+
+
+ /* TOOLTIP PUBLIC CLASS DEFINITION
+  * =============================== */
+
+  var Tooltip = function (element, options) {
+    this.init('tooltip', element, options)
+  }
+
+  Tooltip.prototype = {
+
+    constructor: Tooltip
+
+  , init: function (type, element, options) {
+      var eventIn
+        , eventOut
+        , triggers
+        , trigger
+        , i
+
+      this.type = type
+      this.$element = $(element)
+      this.options = this.getOptions(options)
+      this.enabled = true
+
+      triggers = this.options.trigger.split(' ')
+
+      for (i = triggers.length; i--;) {
+        trigger = triggers[i]
+        if (trigger == 'click') {
+          this.$element.on('click.' + this.type, this.options.selector, $.proxy(this.toggle, this))
+        } else if (trigger != 'manual') {
+          eventIn = trigger == 'hover' ? 'mouseenter' : 'focus'
+          eventOut = trigger == 'hover' ? 'mouseleave' : 'blur'
+          this.$element.on(eventIn + '.' + this.type, this.options.selector, $.proxy(this.enter, this))
+          this.$element.on(eventOut + '.' + this.type, this.options.selector, $.proxy(this.leave, this))
+        }
+      }
+
+      this.options.selector ?
+        (this._options = $.extend({}, this.options, { trigger: 'manual', selector: '' })) :
+        this.fixTitle()
+    }
+
+  , getOptions: function (options) {
+      options = $.extend({}, $.fn[this.type].defaults, this.$element.data(), options)
+
+      if (options.delay && typeof options.delay == 'number') {
+        options.delay = {
+          show: options.delay
+        , hide: options.delay
+        }
+      }
+
+      return options
+    }
+
+  , enter: function (e) {
+      var self = $(e.currentTarget)[this.type](this._options).data(this.type)
+
+      if (!self.options.delay || !self.options.delay.show) return self.show()
+
+      clearTimeout(this.timeout)
+      self.hoverState = 'in'
+      this.timeout = setTimeout(function() {
+        if (self.hoverState == 'in') self.show()
+      }, self.options.delay.show)
+    }
+
+  , leave: function (e) {
+      var self = $(e.currentTarget)[this.type](this._options).data(this.type)
+
+      if (this.timeout) clearTimeout(this.timeout)
+      if (!self.options.delay || !self.options.delay.hide) return self.hide()
+
+      self.hoverState = 'out'
+      this.timeout = setTimeout(function() {
+        if (self.hoverState == 'out') self.hide()
+      }, self.options.delay.hide)
+    }
+
+  , show: function () {
+      var $tip
+        , pos
+        , actualWidth
+        , actualHeight
+        , placement
+        , tp
+        , e = $.Event('show')
+
+      if (this.hasContent() && this.enabled) {
+        this.$element.trigger(e)
+        if (e.isDefaultPrevented()) return
+        $tip = this.tip()
+        this.setContent()
+
+        if (this.options.animation) {
+          $tip.addClass('fade')
+        }
+
+        placement = typeof this.options.placement == 'function' ?
+          this.options.placement.call(this, $tip[0], this.$element[0]) :
+          this.options.placement
+
+        $tip
+          .detach()
+          .css({ top: 0, left: 0, display: 'block' })
+
+        this.options.container ? $tip.appendTo(this.options.container) : $tip.insertAfter(this.$element)
+
+        pos = this.getPosition()
+
+        actualWidth = $tip[0].offsetWidth
+        actualHeight = $tip[0].offsetHeight
+
+        switch (placement) {
+          case 'bottom':
+            tp = {top: pos.top + pos.height, left: pos.left + pos.width / 2 - actualWidth / 2}
+            break
+          case 'top':
+            tp = {top: pos.top - actualHeight, left: pos.left + pos.width / 2 - actualWidth / 2}
+            break
+          case 'left':
+            tp = {top: pos.top + pos.height / 2 - actualHeight / 2, left: pos.left - actualWidth}
+            break
+          case 'right':
+            tp = {top: pos.top + pos.height / 2 - actualHeight / 2, left: pos.left + pos.width}
+            break
+        }
+
+        this.applyPlacement(tp, placement)
+        this.$element.trigger('shown')
+      }
+    }
+
+  , applyPlacement: function(offset, placement){
+      var $tip = this.tip()
+        , width = $tip[0].offsetWidth
+        , height = $tip[0].offsetHeight
+        , actualWidth
+        , actualHeight
+        , delta
+        , replace
+
+      $tip
+        .offset(offset)
+        .addClass(placement)
+        .addClass('in')
+
+      actualWidth = $tip[0].offsetWidth
+      actualHeight = $tip[0].offsetHeight
+
+      if (placement == 'top' && actualHeight != height) {
+        offset.top = offset.top + height - actualHeight
+        replace = true
+      }
+
+      if (placement == 'bottom' || placement == 'top') {
+        delta = 0
+
+        if (offset.left < 0){
+          delta = offset.left * -2
+          offset.left = 0
+          $tip.offset(offset)
+          actualWidth = $tip[0].offsetWidth
+          actualHeight = $tip[0].offsetHeight
+        }
+
+        this.replaceArrow(delta - width + actualWidth, actualWidth, 'left')
+      } else {
+        this.replaceArrow(actualHeight - height, actualHeight, 'top')
+      }
+
+      if (replace) $tip.offset(offset)
+    }
+
+  , replaceArrow: function(delta, dimension, position){
+      this
+        .arrow()
+        .css(position, delta ? (50 * (1 - delta / dimension) + "%") : '')
+    }
+
+  , setContent: function () {
+      var $tip = this.tip()
+        , title = this.getTitle()
+
+      $tip.find('.tooltip-inner')[this.options.html ? 'html' : 'text'](title)
+      $tip.removeClass('fade in top bottom left right')
+    }
+
+  , hide: function () {
+      var that = this
+        , $tip = this.tip()
+        , e = $.Event('hide')
+
+      this.$element.trigger(e)
+      if (e.isDefaultPrevented()) return
+
+      $tip.removeClass('in')
+
+      function removeWithAnimation() {
+        var timeout = setTimeout(function () {
+          $tip.off($.support.transition.end).detach()
+        }, 500)
+
+        $tip.one($.support.transition.end, function () {
+          clearTimeout(timeout)
+          $tip.detach()
+        })
+      }
+
+      $.support.transition && this.$tip.hasClass('fade') ?
+        removeWithAnimation() :
+        $tip.detach()
+
+      this.$element.trigger('hidden')
+
+      return this
+    }
+
+  , fixTitle: function () {
+      var $e = this.$element
+      if ($e.attr('title') || typeof($e.attr('data-original-title')) != 'string') {
+        $e.attr('data-original-title', $e.attr('title') || '').attr('title', '')
+      }
+    }
+
+  , hasContent: function () {
+      return this.getTitle()
+    }
+
+  , getPosition: function () {
+      var el = this.$element[0]
+      return $.extend({}, (typeof el.getBoundingClientRect == 'function') ? el.getBoundingClientRect() : {
+        width: el.offsetWidth
+      , height: el.offsetHeight
+      }, this.$element.offset())
+    }
+
+  , getTitle: function () {
+      var title
+        , $e = this.$element
+        , o = this.options
+
+      title = $e.attr('data-original-title')
+        || (typeof o.title == 'function' ? o.title.call($e[0]) :  o.title)
+
+      return title
+    }
+
+  , tip: function () {
+      return this.$tip = this.$tip || $(this.options.template)
+    }
+
+  , arrow: function(){
+      return this.$arrow = this.$arrow || this.tip().find(".tooltip-arrow")
+    }
+
+  , validate: function () {
+      if (!this.$element[0].parentNode) {
+        this.hide()
+        this.$element = null
+        this.options = null
+      }
+    }
+
+  , enable: function () {
+      this.enabled = true
+    }
+
+  , disable: function () {
+      this.enabled = false
+    }
+
+  , toggleEnabled: function () {
+      this.enabled = !this.enabled
+    }
+
+  , toggle: function (e) {
+      var self = e ? $(e.currentTarget)[this.type](this._options).data(this.type) : this
+      self.tip().hasClass('in') ? self.hide() : self.show()
+    }
+
+  , destroy: function () {
+      this.hide().$element.off('.' + this.type).removeData(this.type)
+    }
+
+  }
+
+
+ /* TOOLTIP PLUGIN DEFINITION
+  * ========================= */
+
+  var old = $.fn.tooltip
+
+  $.fn.tooltip = function ( option ) {
+    return this.each(function () {
+      var $this = $(this)
+        , data = $this.data('tooltip')
+        , options = typeof option == 'object' && option
+      if (!data) $this.data('tooltip', (data = new Tooltip(this, options)))
+      if (typeof option == 'string') data[option]()
+    })
+  }
+
+  $.fn.tooltip.Constructor = Tooltip
+
+  $.fn.tooltip.defaults = {
+    animation: true
+  , placement: 'top'
+  , selector: false
+  , template: '<div class="tooltip"><div class="tooltip-arrow"></div><div class="tooltip-inner"></div></div>'
+  , trigger: 'hover focus'
+  , title: ''
+  , delay: 0
+  , html: false
+  , container: false
+  }
+
+
+ /* TOOLTIP NO CONFLICT
+  * =================== */
+
+  $.fn.tooltip.noConflict = function () {
+    $.fn.tooltip = old
+    return this
+  }
+
+}(window.jQuery);
+
+/* ===========================================================
+ * bootstrap-popover.js v2.3.0
+ * http://twitter.github.com/bootstrap/javascript.html#popovers
+ * ===========================================================
+ * Copyright 2012 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =========================================================== */
+
+
+!function ($) {
+
+  "use strict"; // jshint ;_;
+
+
+ /* POPOVER PUBLIC CLASS DEFINITION
+  * =============================== */
+
+  var Popover = function (element, options) {
+    this.init('popover', element, options)
+  }
+
+
+  /* NOTE: POPOVER EXTENDS BOOTSTRAP-TOOLTIP.js
+     ========================================== */
+
+  Popover.prototype = $.extend({}, $.fn.tooltip.Constructor.prototype, {
+
+    constructor: Popover
+
+  , setContent: function () {
+      var $tip = this.tip()
+        , title = this.getTitle()
+        , content = this.getContent()
+
+      $tip.find('.popover-title')[this.options.html ? 'html' : 'text'](title)
+      $tip.find('.popover-content')[this.options.html ? 'html' : 'text'](content)
+
+      $tip.removeClass('fade top bottom left right in')
+    }
+
+  , hasContent: function () {
+      return this.getTitle() || this.getContent()
+    }
+
+  , getContent: function () {
+      var content
+        , $e = this.$element
+        , o = this.options
+
+      content = (typeof o.content == 'function' ? o.content.call($e[0]) :  o.content)
+        || $e.attr('data-content')
+
+      return content
+    }
+
+  , tip: function () {
+      if (!this.$tip) {
+        this.$tip = $(this.options.template)
+      }
+      return this.$tip
+    }
+
+  , destroy: function () {
+      this.hide().$element.off('.' + this.type).removeData(this.type)
+    }
+
+  })
+
+
+ /* POPOVER PLUGIN DEFINITION
+  * ======================= */
+
+  var old = $.fn.popover
+
+  $.fn.popover = function (option) {
+    return this.each(function () {
+      var $this = $(this)
+        , data = $this.data('popover')
+        , options = typeof option == 'object' && option
+      if (!data) $this.data('popover', (data = new Popover(this, options)))
+      if (typeof option == 'string') data[option]()
+    })
+  }
+
+  $.fn.popover.Constructor = Popover
+
+  $.fn.popover.defaults = $.extend({} , $.fn.tooltip.defaults, {
+    placement: 'right'
+  , trigger: 'click'
+  , content: ''
+  , template: '<div class="popover"><div class="arrow"></div><h3 class="popover-title"></h3><div class="popover-content"></div></div>'
+  })
+
+
+ /* POPOVER NO CONFLICT
+  * =================== */
+
+  $.fn.popover.noConflict = function () {
+    $.fn.popover = old
+    return this
+  }
+
+}(window.jQuery);
+
+/* ==========================================================
+ * bootstrap-affix.js v2.3.0
+ * http://twitter.github.com/bootstrap/javascript.html#affix
+ * ==========================================================
+ * Copyright 2012 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ========================================================== */
+
+
+!function ($) {
+
+  "use strict"; // jshint ;_;
+
+
+ /* AFFIX CLASS DEFINITION
+  * ====================== */
+
+  var Affix = function (element, options) {
+    this.options = $.extend({}, $.fn.affix.defaults, options)
+    this.$window = $(window)
+      .on('scroll.affix.data-api', $.proxy(this.checkPosition, this))
+      .on('click.affix.data-api',  $.proxy(function () { setTimeout($.proxy(this.checkPosition, this), 1) }, this))
+    this.$element = $(element)
+    this.checkPosition()
+  }
+
+  Affix.prototype.checkPosition = function () {
+    if (!this.$element.is(':visible')) return
+
+    var scrollHeight = $(document).height()
+      , scrollTop = this.$window.scrollTop()
+      , position = this.$element.offset()
+      , offset = this.options.offset
+      , offsetBottom = offset.bottom
+      , offsetTop = offset.top
+      , reset = 'affix affix-top affix-bottom'
+      , affix
+
+    if (typeof offset != 'object') offsetBottom = offsetTop = offset
+    if (typeof offsetTop == 'function') offsetTop = offset.top()
+    if (typeof offsetBottom == 'function') offsetBottom = offset.bottom()
+
+    affix = this.unpin != null && (scrollTop + this.unpin <= position.top) ?
+      false    : offsetBottom != null && (position.top + this.$element.height() >= scrollHeight - offsetBottom) ?
+      'bottom' : offsetTop != null && scrollTop <= offsetTop ?
+      'top'    : false
+
+    if (this.affixed === affix) return
+
+    this.affixed = affix
+    this.unpin = affix == 'bottom' ? position.top - scrollTop : null
+
+    this.$element.removeClass(reset).addClass('affix' + (affix ? '-' + affix : ''))
+  }
+
+
+ /* AFFIX PLUGIN DEFINITION
+  * ======================= */
+
+  var old = $.fn.affix
+
+  $.fn.affix = function (option) {
+    return this.each(function () {
+      var $this = $(this)
+        , data = $this.data('affix')
+        , options = typeof option == 'object' && option
+      if (!data) $this.data('affix', (data = new Affix(this, options)))
+      if (typeof option == 'string') data[option]()
+    })
+  }
+
+  $.fn.affix.Constructor = Affix
+
+  $.fn.affix.defaults = {
+    offset: 0
+  }
+
+
+ /* AFFIX NO CONFLICT
+  * ================= */
+
+  $.fn.affix.noConflict = function () {
+    $.fn.affix = old
+    return this
+  }
+
+
+ /* AFFIX DATA-API
+  * ============== */
+
+  $(window).on('load', function () {
+    $('[data-spy="affix"]').each(function () {
+      var $spy = $(this)
+        , data = $spy.data()
+
+      data.offset = data.offset || {}
+
+      data.offsetBottom && (data.offset.bottom = data.offsetBottom)
+      data.offsetTop && (data.offset.top = data.offsetTop)
+
+      $spy.affix(data)
+    })
+  })
+
+
+}(window.jQuery);
+/* ==========================================================
+ * bootstrap-alert.js v2.3.0
+ * http://twitter.github.com/bootstrap/javascript.html#alerts
+ * ==========================================================
+ * Copyright 2012 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ========================================================== */
+
+
+!function ($) {
+
+  "use strict"; // jshint ;_;
+
+
+ /* ALERT CLASS DEFINITION
+  * ====================== */
+
+  var dismiss = '[data-dismiss="alert"]'
+    , Alert = function (el) {
+        $(el).on('click', dismiss, this.close)
+      }
+
+  Alert.prototype.close = function (e) {
+    var $this = $(this)
+      , selector = $this.attr('data-target')
+      , $parent
+
+    if (!selector) {
+      selector = $this.attr('href')
+      selector = selector && selector.replace(/.*(?=#[^\s]*$)/, '') //strip for ie7
+    }
+
+    $parent = $(selector)
+
+    e && e.preventDefault()
+
+    $parent.length || ($parent = $this.hasClass('alert') ? $this : $this.parent())
+
+    $parent.trigger(e = $.Event('close'))
+
+    if (e.isDefaultPrevented()) return
+
+    $parent.removeClass('in')
+
+    function removeElement() {
+      $parent
+        .trigger('closed')
+        .remove()
+    }
+
+    $.support.transition && $parent.hasClass('fade') ?
+      $parent.on($.support.transition.end, removeElement) :
+      removeElement()
+  }
+
+
+ /* ALERT PLUGIN DEFINITION
+  * ======================= */
+
+  var old = $.fn.alert
+
+  $.fn.alert = function (option) {
+    return this.each(function () {
+      var $this = $(this)
+        , data = $this.data('alert')
+      if (!data) $this.data('alert', (data = new Alert(this)))
+      if (typeof option == 'string') data[option].call($this)
+    })
+  }
+
+  $.fn.alert.Constructor = Alert
+
+
+ /* ALERT NO CONFLICT
+  * ================= */
+
+  $.fn.alert.noConflict = function () {
+    $.fn.alert = old
+    return this
+  }
+
+
+ /* ALERT DATA-API
+  * ============== */
+
+  $(document).on('click.alert.data-api', dismiss, Alert.prototype.close)
+
+}(window.jQuery);
+/* ============================================================
+ * bootstrap-button.js v2.3.0
+ * http://twitter.github.com/bootstrap/javascript.html#buttons
+ * ============================================================
+ * Copyright 2012 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============================================================ */
+
+
+!function ($) {
+
+  "use strict"; // jshint ;_;
+
+
+ /* BUTTON PUBLIC CLASS DEFINITION
+  * ============================== */
+
+  var Button = function (element, options) {
+    this.$element = $(element)
+    this.options = $.extend({}, $.fn.button.defaults, options)
+  }
+
+  Button.prototype.setState = function (state) {
+    var d = 'disabled'
+      , $el = this.$element
+      , data = $el.data()
+      , val = $el.is('input') ? 'val' : 'html'
+
+    state = state + 'Text'
+    data.resetText || $el.data('resetText', $el[val]())
+
+    $el[val](data[state] || this.options[state])
+
+    // push to event loop to allow forms to submit
+    setTimeout(function () {
+      state == 'loadingText' ?
+        $el.addClass(d).attr(d, d) :
+        $el.removeClass(d).removeAttr(d)
+    }, 0)
+  }
+
+  Button.prototype.toggle = function () {
+    var $parent = this.$element.closest('[data-toggle="buttons-radio"]')
+
+    $parent && $parent
+      .find('.active')
+      .removeClass('active')
+
+    this.$element.toggleClass('active')
+  }
+
+
+ /* BUTTON PLUGIN DEFINITION
+  * ======================== */
+
+  var old = $.fn.button
+
+  $.fn.button = function (option) {
+    return this.each(function () {
+      var $this = $(this)
+        , data = $this.data('button')
+        , options = typeof option == 'object' && option
+      if (!data) $this.data('button', (data = new Button(this, options)))
+      if (option == 'toggle') data.toggle()
+      else if (option) data.setState(option)
+    })
+  }
+
+  $.fn.button.defaults = {
+    loadingText: 'loading...'
+  }
+
+  $.fn.button.Constructor = Button
+
+
+ /* BUTTON NO CONFLICT
+  * ================== */
+
+  $.fn.button.noConflict = function () {
+    $.fn.button = old
+    return this
+  }
+
+
+ /* BUTTON DATA-API
+  * =============== */
+
+  $(document).on('click.button.data-api', '[data-toggle^=button]', function (e) {
+    var $btn = $(e.target)
+    if (!$btn.hasClass('btn')) $btn = $btn.closest('.btn')
+    $btn.button('toggle')
+  })
+
+}(window.jQuery);
+/* =============================================================
+ * bootstrap-collapse.js v2.3.0
+ * http://twitter.github.com/bootstrap/javascript.html#collapse
+ * =============================================================
+ * Copyright 2012 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============================================================ */
+
+
+!function ($) {
+
+  "use strict"; // jshint ;_;
+
+
+ /* COLLAPSE PUBLIC CLASS DEFINITION
+  * ================================ */
+
+  var Collapse = function (element, options) {
+    this.$element = $(element)
+    this.options = $.extend({}, $.fn.collapse.defaults, options)
+
+    if (this.options.parent) {
+      this.$parent = $(this.options.parent)
+    }
+
+    this.options.toggle && this.toggle()
+  }
+
+  Collapse.prototype = {
+
+    constructor: Collapse
+
+  , dimension: function () {
+      var hasWidth = this.$element.hasClass('width')
+      return hasWidth ? 'width' : 'height'
+    }
+
+  , show: function () {
+      var dimension
+        , scroll
+        , actives
+        , hasData
+
+      if (this.transitioning || this.$element.hasClass('in')) return
+
+      dimension = this.dimension()
+      scroll = $.camelCase(['scroll', dimension].join('-'))
+      actives = this.$parent && this.$parent.find('> .accordion-group > .in')
+
+      if (actives && actives.length) {
+        hasData = actives.data('collapse')
+        if (hasData && hasData.transitioning) return
+        actives.collapse('hide')
+        hasData || actives.data('collapse', null)
+      }
+
+      this.$element[dimension](0)
+      this.transition('addClass', $.Event('show'), 'shown')
+      $.support.transition && this.$element[dimension](this.$element[0][scroll])
+    }
+
+  , hide: function () {
+      var dimension
+      if (this.transitioning || !this.$element.hasClass('in')) return
+      dimension = this.dimension()
+      this.reset(this.$element[dimension]())
+      this.transition('removeClass', $.Event('hide'), 'hidden')
+      this.$element[dimension](0)
+    }
+
+  , reset: function (size) {
+      var dimension = this.dimension()
+
+      this.$element
+        .removeClass('collapse')
+        [dimension](size || 'auto')
+        [0].offsetWidth
+
+      this.$element[size !== null ? 'addClass' : 'removeClass']('collapse')
+
+      return this
+    }
+
+  , transition: function (method, startEvent, completeEvent) {
+      var that = this
+        , complete = function () {
+            if (startEvent.type == 'show') that.reset()
+            that.transitioning = 0
+            that.$element.trigger(completeEvent)
+          }
+
+      this.$element.trigger(startEvent)
+
+      if (startEvent.isDefaultPrevented()) return
+
+      this.transitioning = 1
+
+      this.$element[method]('in')
+
+      $.support.transition && this.$element.hasClass('collapse') ?
+        this.$element.one($.support.transition.end, complete) :
+        complete()
+    }
+
+  , toggle: function () {
+      this[this.$element.hasClass('in') ? 'hide' : 'show']()
+    }
+
+  }
+
+
+ /* COLLAPSE PLUGIN DEFINITION
+  * ========================== */
+
+  var old = $.fn.collapse
+
+  $.fn.collapse = function (option) {
+    return this.each(function () {
+      var $this = $(this)
+        , data = $this.data('collapse')
+        , options = $.extend({}, $.fn.collapse.defaults, $this.data(), typeof option == 'object' && option)
+      if (!data) $this.data('collapse', (data = new Collapse(this, options)))
+      if (typeof option == 'string') data[option]()
+    })
+  }
+
+  $.fn.collapse.defaults = {
+    toggle: true
+  }
+
+  $.fn.collapse.Constructor = Collapse
+
+
+ /* COLLAPSE NO CONFLICT
+  * ==================== */
+
+  $.fn.collapse.noConflict = function () {
+    $.fn.collapse = old
+    return this
+  }
+
+
+ /* COLLAPSE DATA-API
+  * ================= */
+
+  $(document).on('click.collapse.data-api', '[data-toggle=collapse]', function (e) {
+    var $this = $(this), href
+      , target = $this.attr('data-target')
+        || e.preventDefault()
+        || (href = $this.attr('href')) && href.replace(/.*(?=#[^\s]+$)/, '') //strip for ie7
+      , option = $(target).data('collapse') ? 'toggle' : $this.data()
+    $this[$(target).hasClass('in') ? 'addClass' : 'removeClass']('collapsed')
+    $(target).collapse(option)
+  })
+
+}(window.jQuery);
+/* ==========================================================
+ * bootstrap-carousel.js v2.3.0
+ * http://twitter.github.com/bootstrap/javascript.html#carousel
+ * ==========================================================
+ * Copyright 2012 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ========================================================== */
+
+
+!function ($) {
+
+  "use strict"; // jshint ;_;
+
+
+ /* CAROUSEL CLASS DEFINITION
+  * ========================= */
+
+  var Carousel = function (element, options) {
+    this.$element = $(element)
+    this.$indicators = this.$element.find('.carousel-indicators')
+    this.options = options
+    this.options.pause == 'hover' && this.$element
+      .on('mouseenter', $.proxy(this.pause, this))
+      .on('mouseleave', $.proxy(this.cycle, this))
+  }
+
+  Carousel.prototype = {
+
+    cycle: function (e) {
+      if (!e) this.paused = false
+      if (this.interval) clearInterval(this.interval);
+      this.options.interval
+        && !this.paused
+        && (this.interval = setInterval($.proxy(this.next, this), this.options.interval))
+      return this
+    }
+
+  , getActiveIndex: function () {
+      this.$active = this.$element.find('.item.active')
+      this.$items = this.$active.parent().children()
+      return this.$items.index(this.$active)
+    }
+
+  , to: function (pos) {
+      var activeIndex = this.getActiveIndex()
+        , that = this
+
+      if (pos > (this.$items.length - 1) || pos < 0) return
+
+      if (this.sliding) {
+        return this.$element.one('slid', function () {
+          that.to(pos)
+        })
+      }
+
+      if (activeIndex == pos) {
+        return this.pause().cycle()
+      }
+
+      return this.slide(pos > activeIndex ? 'next' : 'prev', $(this.$items[pos]))
+    }
+
+  , pause: function (e) {
+      if (!e) this.paused = true
+      if (this.$element.find('.next, .prev').length && $.support.transition.end) {
+        this.$element.trigger($.support.transition.end)
+        this.cycle()
+      }
+      clearInterval(this.interval)
+      this.interval = null
+      return this
+    }
+
+  , next: function () {
+      if (this.sliding) return
+      return this.slide('next')
+    }
+
+  , prev: function () {
+      if (this.sliding) return
+      return this.slide('prev')
+    }
+
+  , slide: function (type, next) {
+      var $active = this.$element.find('.item.active')
+        , $next = next || $active[type]()
+        , isCycling = this.interval
+        , direction = type == 'next' ? 'left' : 'right'
+        , fallback  = type == 'next' ? 'first' : 'last'
+        , that = this
+        , e
+
+      this.sliding = true
+
+      isCycling && this.pause()
+
+      $next = $next.length ? $next : this.$element.find('.item')[fallback]()
+
+      e = $.Event('slide', {
+        relatedTarget: $next[0]
+      , direction: direction
+      })
+
+      if ($next.hasClass('active')) return
+
+      if (this.$indicators.length) {
+        this.$indicators.find('.active').removeClass('active')
+        this.$element.one('slid', function () {
+          var $nextIndicator = $(that.$indicators.children()[that.getActiveIndex()])
+          $nextIndicator && $nextIndicator.addClass('active')
+        })
+      }
+
+      if ($.support.transition && this.$element.hasClass('slide')) {
+        this.$element.trigger(e)
+        if (e.isDefaultPrevented()) return
+        $next.addClass(type)
+        $next[0].offsetWidth // force reflow
+        $active.addClass(direction)
+        $next.addClass(direction)
+        this.$element.one($.support.transition.end, function () {
+          $next.removeClass([type, direction].join(' ')).addClass('active')
+          $active.removeClass(['active', direction].join(' '))
+          that.sliding = false
+          setTimeout(function () { that.$element.trigger('slid') }, 0)
+        })
+      } else {
+        this.$element.trigger(e)
+        if (e.isDefaultPrevented()) return
+        $active.removeClass('active')
+        $next.addClass('active')
+        this.sliding = false
+        this.$element.trigger('slid')
+      }
+
+      isCycling && this.cycle()
+
+      return this
+    }
+
+  }
+
+
+ /* CAROUSEL PLUGIN DEFINITION
+  * ========================== */
+
+  var old = $.fn.carousel
+
+  $.fn.carousel = function (option) {
+    return this.each(function () {
+      var $this = $(this)
+        , data = $this.data('carousel')
+        , options = $.extend({}, $.fn.carousel.defaults, typeof option == 'object' && option)
+        , action = typeof option == 'string' ? option : options.slide
+      if (!data) $this.data('carousel', (data = new Carousel(this, options)))
+      if (typeof option == 'number') data.to(option)
+      else if (action) data[action]()
+      else if (options.interval) data.pause().cycle()
+    })
+  }
+
+  $.fn.carousel.defaults = {
+    interval: 5000
+  , pause: 'hover'
+  }
+
+  $.fn.carousel.Constructor = Carousel
+
+
+ /* CAROUSEL NO CONFLICT
+  * ==================== */
+
+  $.fn.carousel.noConflict = function () {
+    $.fn.carousel = old
+    return this
+  }
+
+ /* CAROUSEL DATA-API
+  * ================= */
+
+  $(document).on('click.carousel.data-api', '[data-slide], [data-slide-to]', function (e) {
+    var $this = $(this), href
+      , $target = $($this.attr('data-target') || (href = $this.attr('href')) && href.replace(/.*(?=#[^\s]+$)/, '')) //strip for ie7
+      , options = $.extend({}, $target.data(), $this.data())
+      , slideIndex
+
+    $target.carousel(options)
+
+    if (slideIndex = $this.attr('data-slide-to')) {
+      $target.data('carousel').pause().to(slideIndex).cycle()
+    }
+
+    e.preventDefault()
+  })
+
+}(window.jQuery);
+/* =============================================================
+ * bootstrap-typeahead.js v2.3.0
+ * http://twitter.github.com/bootstrap/javascript.html#typeahead
+ * =============================================================
+ * Copyright 2012 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============================================================ */
+
+
+!function($){
+
+  "use strict"; // jshint ;_;
+
+
+ /* TYPEAHEAD PUBLIC CLASS DEFINITION
+  * ================================= */
+
+  var Typeahead = function (element, options) {
+    this.$element = $(element)
+    this.options = $.extend({}, $.fn.typeahead.defaults, options)
+    this.matcher = this.options.matcher || this.matcher
+    this.sorter = this.options.sorter || this.sorter
+    this.highlighter = this.options.highlighter || this.highlighter
+    this.updater = this.options.updater || this.updater
+    this.source = this.options.source
+    this.$menu = $(this.options.menu)
+    this.shown = false
+    this.listen()
+  }
+
+  Typeahead.prototype = {
+
+    constructor: Typeahead
+
+  , select: function () {
+      var val = this.$menu.find('.active').attr('data-value')
+      this.$element
+        .val(this.updater(val))
+        .change()
+      return this.hide()
+    }
+
+  , updater: function (item) {
+      return item
+    }
+
+  , show: function () {
+      var pos = $.extend({}, this.$element.position(), {
+        height: this.$element[0].offsetHeight
+      })
+
+      this.$menu
+        .insertAfter(this.$element)
+        .css({
+          top: pos.top + pos.height
+        , left: pos.left
+        })
+        .show()
+
+      this.shown = true
+      return this
+    }
+
+  , hide: function () {
+      this.$menu.hide()
+      this.shown = false
+      return this
+    }
+
+  , lookup: function (event) {
+      var items
+
+      this.query = this.$element.val()
+
+      if (!this.query || this.query.length < this.options.minLength) {
+        return this.shown ? this.hide() : this
+      }
+
+      items = $.isFunction(this.source) ? this.source(this.query, $.proxy(this.process, this)) : this.source
+
+      return items ? this.process(items) : this
+    }
+
+  , process: function (items) {
+      var that = this
+
+      items = $.grep(items, function (item) {
+        return that.matcher(item)
+      })
+
+      items = this.sorter(items)
+
+      if (!items.length) {
+        return this.shown ? this.hide() : this
+      }
+
+      return this.render(items.slice(0, this.options.items)).show()
+    }
+
+  , matcher: function (item) {
+      return ~item.toLowerCase().indexOf(this.query.toLowerCase())
+    }
+
+  , sorter: function (items) {
+      var beginswith = []
+        , caseSensitive = []
+        , caseInsensitive = []
+        , item
+
+      while (item = items.shift()) {
+        if (!item.toLowerCase().indexOf(this.query.toLowerCase())) beginswith.push(item)
+        else if (~item.indexOf(this.query)) caseSensitive.push(item)
+        else caseInsensitive.push(item)
+      }
+
+      return beginswith.concat(caseSensitive, caseInsensitive)
+    }
+
+  , highlighter: function (item) {
+      var query = this.query.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, '\\$&')
+      return item.replace(new RegExp('(' + query + ')', 'ig'), function ($1, match) {
+        return '<strong>' + match + '</strong>'
+      })
+    }
+
+  , render: function (items) {
+      var that = this
+
+      items = $(items).map(function (i, item) {
+        i = $(that.options.item).attr('data-value', item)
+        i.find('a').html(that.highlighter(item))
+        return i[0]
+      })
+
+      items.first().addClass('active')
+      this.$menu.html(items)
+      return this
+    }
+
+  , next: function (event) {
+      var active = this.$menu.find('.active').removeClass('active')
+        , next = active.next()
+
+      if (!next.length) {
+        next = $(this.$menu.find('li')[0])
+      }
+
+      next.addClass('active')
+    }
+
+  , prev: function (event) {
+      var active = this.$menu.find('.active').removeClass('active')
+        , prev = active.prev()
+
+      if (!prev.length) {
+        prev = this.$menu.find('li').last()
+      }
+
+      prev.addClass('active')
+    }
+
+  , listen: function () {
+      this.$element
+        .on('focus',    $.proxy(this.focus, this))
+        .on('blur',     $.proxy(this.blur, this))
+        .on('keypress', $.proxy(this.keypress, this))
+        .on('keyup',    $.proxy(this.keyup, this))
+
+      if (this.eventSupported('keydown')) {
+        this.$element.on('keydown', $.proxy(this.keydown, this))
+      }
+
+      this.$menu
+        .on('click', $.proxy(this.click, this))
+        .on('mouseenter', 'li', $.proxy(this.mouseenter, this))
+        .on('mouseleave', 'li', $.proxy(this.mouseleave, this))
+    }
+
+  , eventSupported: function(eventName) {
+      var isSupported = eventName in this.$element
+      if (!isSupported) {
+        this.$element.setAttribute(eventName, 'return;')
+        isSupported = typeof this.$element[eventName] === 'function'
+      }
+      return isSupported
+    }
+
+  , move: function (e) {
+      if (!this.shown) return
+
+      switch(e.keyCode) {
+        case 9: // tab
+        case 13: // enter
+        case 27: // escape
+          e.preventDefault()
+          break
+
+        case 38: // up arrow
+          e.preventDefault()
+          this.prev()
+          break
+
+        case 40: // down arrow
+          e.preventDefault()
+          this.next()
+          break
+      }
+
+      e.stopPropagation()
+    }
+
+  , keydown: function (e) {
+      this.suppressKeyPressRepeat = ~$.inArray(e.keyCode, [40,38,9,13,27])
+      this.move(e)
+    }
+
+  , keypress: function (e) {
+      if (this.suppressKeyPressRepeat) return
+      this.move(e)
+    }
+
+  , keyup: function (e) {
+      switch(e.keyCode) {
+        case 40: // down arrow
+        case 38: // up arrow
+        case 16: // shift
+        case 17: // ctrl
+        case 18: // alt
+          break
+
+        case 9: // tab
+        case 13: // enter
+          if (!this.shown) return
+          this.select()
+          break
+
+        case 27: // escape
+          if (!this.shown) return
+          this.hide()
+          break
+
+        default:
+          this.lookup()
+      }
+
+      e.stopPropagation()
+      e.preventDefault()
+  }
+
+  , focus: function (e) {
+      this.focused = true
+    }
+
+  , blur: function (e) {
+      this.focused = false
+      if (!this.mousedover && this.shown) this.hide()
+    }
+
+  , click: function (e) {
+      e.stopPropagation()
+      e.preventDefault()
+      this.select()
+      this.$element.focus()
+    }
+
+  , mouseenter: function (e) {
+      this.mousedover = true
+      this.$menu.find('.active').removeClass('active')
+      $(e.currentTarget).addClass('active')
+    }
+
+  , mouseleave: function (e) {
+      this.mousedover = false
+      if (!this.focused && this.shown) this.hide()
+    }
+
+  }
+
+
+  /* TYPEAHEAD PLUGIN DEFINITION
+   * =========================== */
+
+  var old = $.fn.typeahead
+
+  $.fn.typeahead = function (option) {
+    return this.each(function () {
+      var $this = $(this)
+        , data = $this.data('typeahead')
+        , options = typeof option == 'object' && option
+      if (!data) $this.data('typeahead', (data = new Typeahead(this, options)))
+      if (typeof option == 'string') data[option]()
+    })
+  }
+
+  $.fn.typeahead.defaults = {
+    source: []
+  , items: 8
+  , menu: '<ul class="typeahead dropdown-menu"></ul>'
+  , item: '<li><a href="#"></a></li>'
+  , minLength: 1
+  }
+
+  $.fn.typeahead.Constructor = Typeahead
+
+
+ /* TYPEAHEAD NO CONFLICT
+  * =================== */
+
+  $.fn.typeahead.noConflict = function () {
+    $.fn.typeahead = old
+    return this
+  }
+
+
+ /* TYPEAHEAD DATA-API
+  * ================== */
+
+  $(document).on('focus.typeahead.data-api', '[data-provide="typeahead"]', function (e) {
+    var $this = $(this)
+    if ($this.data('typeahead')) return
+    $this.typeahead($this.data())
+  })
+
+}(window.jQuery);
diff --git a/module/web/static/js/libs/handlebars.l b/module/web/static/js/libs/handlebars.l
new file mode 100644
index 000000000..f0c04f91e
--- /dev/null
+++ b/module/web/static/js/libs/handlebars.l
@@ -0,0 +1,48 @@
+
+%x mu emu
+
+%%
+
+[^\x00]*?/("<%")                 {
+                                   if(yytext.slice(-1) !== "\\") this.begin("mu");
+                                   if(yytext.slice(-1) === "\\") yytext = yytext.substr(0,yyleng-1), this.begin("emu");
+                                   if(yytext) return 'CONTENT';
+                                 }
+
+[^\x00]+                         { return 'CONTENT'; }
+
+<emu>[^\x00]{2,}?/("{{"|<<EOF>>) {
+                                   if(yytext.slice(-1) !== "\\") this.popState();
+                                   if(yytext.slice(-1) === "\\") yytext = yytext.substr(0,yyleng-1);
+                                   return 'CONTENT';
+                                 }
+
+<mu>"{{>"                        { return 'OPEN_PARTIAL'; }
+<mu>"<%="                        { return 'OPEN_BLOCK'; }
+<mu>"<%/"                        { return 'OPEN_ENDBLOCK'; }
+<mu>"{{^"                        { return 'OPEN_INVERSE'; }
+<mu>"<%"\s*"else"                { return 'OPEN_INVERSE'; }
+<mu>"{<%%"                        { return 'OPEN_UNESCAPED'; }
+<mu>"{{&"                        { return 'OPEN_UNESCAPED'; }
+<mu>"<%!"[\s\S]*?"%>"            { yytext = yytext.substr(3,yyleng-5); this.popState(); return 'COMMENT'; }
+<mu>"<%"                         { return 'OPEN'; }
+
+<mu>"="                          { return 'EQUALS'; }
+<mu>"."/[%} ]                     { return 'ID'; }
+<mu>".."                         { return 'ID'; }
+<mu>[\/.]                        { return 'SEP'; }
+<mu>\s+                          { /*ignore whitespace*/ }
+<mu>"%%>"                        { this.popState(); return 'CLOSE'; }
+<mu>"%>"                         { this.popState(); return 'CLOSE'; }
+<mu>'"'("\\"["]|[^"])*'"'        { yytext = yytext.substr(1,yyleng-2).replace(/\\"/g,'"'); return 'STRING'; }
+<mu>"'"("\\"[']|[^'])*"'"        { yytext = yytext.substr(1,yyleng-2).replace(/\\"/g,'"'); return 'STRING'; }
+<mu>"@"[a-zA-Z]+                 { yytext = yytext.substr(1); return 'DATA'; }
+<mu>"true"/[%}\s]                 { return 'BOOLEAN'; }
+<mu>"false"/[%}\s]                { return 'BOOLEAN'; }
+<mu>[0-9]+/[%}\s]                 { return 'INTEGER'; }
+<mu>[a-zA-Z0-9_$-]+/[=%}\s\/.]    { return 'ID'; }
+<mu>'['[^\]]*']'                 { yytext = yytext.substr(1, yyleng-2); return 'ID'; }
+<mu>.                            { return 'INVALID'; }
+
+<INITIAL,mu><<EOF>>              { return 'EOF'; }
+
diff --git a/module/web/static/js/libs/jquery-1.9.1.js b/module/web/static/js/libs/jquery-1.9.1.js
new file mode 100644
index 000000000..e2c203fe9
--- /dev/null
+++ b/module/web/static/js/libs/jquery-1.9.1.js
@@ -0,0 +1,9597 @@
+/*!
+ * jQuery JavaScript Library v1.9.1
+ * http://jquery.com/
+ *
+ * Includes Sizzle.js
+ * http://sizzlejs.com/
+ *
+ * Copyright 2005, 2012 jQuery Foundation, Inc. and other contributors
+ * Released under the MIT license
+ * http://jquery.org/license
+ *
+ * Date: 2013-2-4
+ */
+(function( window, undefined ) {
+
+// Can't do this because several apps including ASP.NET trace
+// the stack via arguments.caller.callee and Firefox dies if
+// you try to trace through "use strict" call chains. (#13335)
+// Support: Firefox 18+
+//"use strict";
+var
+	// The deferred used on DOM ready
+	readyList,
+
+	// A central reference to the root jQuery(document)
+	rootjQuery,
+
+	// Support: IE<9
+	// For `typeof node.method` instead of `node.method !== undefined`
+	core_strundefined = typeof undefined,
+
+	// Use the correct document accordingly with window argument (sandbox)
+	document = window.document,
+	location = window.location,
+
+	// Map over jQuery in case of overwrite
+	_jQuery = window.jQuery,
+
+	// Map over the $ in case of overwrite
+	_$ = window.$,
+
+	// [[Class]] -> type pairs
+	class2type = {},
+
+	// List of deleted data cache ids, so we can reuse them
+	core_deletedIds = [],
+
+	core_version = "1.9.1",
+
+	// Save a reference to some core methods
+	core_concat = core_deletedIds.concat,
+	core_push = core_deletedIds.push,
+	core_slice = core_deletedIds.slice,
+	core_indexOf = core_deletedIds.indexOf,
+	core_toString = class2type.toString,
+	core_hasOwn = class2type.hasOwnProperty,
+	core_trim = core_version.trim,
+
+	// Define a local copy of jQuery
+	jQuery = function( selector, context ) {
+		// The jQuery object is actually just the init constructor 'enhanced'
+		return new jQuery.fn.init( selector, context, rootjQuery );
+	},
+
+	// Used for matching numbers
+	core_pnum = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,
+
+	// Used for splitting on whitespace
+	core_rnotwhite = /\S+/g,
+
+	// Make sure we trim BOM and NBSP (here's looking at you, Safari 5.0 and IE)
+	rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
+
+	// A simple way to check for HTML strings
+	// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
+	// Strict HTML recognition (#11290: must start with <)
+	rquickExpr = /^(?:(<[\w\W]+>)[^>]*|#([\w-]*))$/,
+
+	// Match a standalone tag
+	rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/,
+
+	// JSON RegExp
+	rvalidchars = /^[\],:{}\s]*$/,
+	rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
+	rvalidescape = /\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g,
+	rvalidtokens = /"[^"\\\r\n]*"|true|false|null|-?(?:\d+\.|)\d+(?:[eE][+-]?\d+|)/g,
+
+	// Matches dashed string for camelizing
+	rmsPrefix = /^-ms-/,
+	rdashAlpha = /-([\da-z])/gi,
+
+	// Used by jQuery.camelCase as callback to replace()
+	fcamelCase = function( all, letter ) {
+		return letter.toUpperCase();
+	},
+
+	// The ready event handler
+	completed = function( event ) {
+
+		// readyState === "complete" is good enough for us to call the dom ready in oldIE
+		if ( document.addEventListener || event.type === "load" || document.readyState === "complete" ) {
+			detach();
+			jQuery.ready();
+		}
+	},
+	// Clean-up method for dom ready events
+	detach = function() {
+		if ( document.addEventListener ) {
+			document.removeEventListener( "DOMContentLoaded", completed, false );
+			window.removeEventListener( "load", completed, false );
+
+		} else {
+			document.detachEvent( "onreadystatechange", completed );
+			window.detachEvent( "onload", completed );
+		}
+	};
+
+jQuery.fn = jQuery.prototype = {
+	// The current version of jQuery being used
+	jquery: core_version,
+
+	constructor: jQuery,
+	init: function( selector, context, rootjQuery ) {
+		var match, elem;
+
+		// HANDLE: $(""), $(null), $(undefined), $(false)
+		if ( !selector ) {
+			return this;
+		}
+
+		// Handle HTML strings
+		if ( typeof selector === "string" ) {
+			if ( selector.charAt(0) === "<" && selector.charAt( 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;
+
+					// scripts is true for back-compat
+					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 ( jQuery.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] );
+
+					// Check parentNode to catch when Blackberry 4.6 returns
+					// nodes that are no longer in the document #6963
+					if ( elem && elem.parentNode ) {
+						// Handle the case where IE and Opera return items
+						// by name instead of ID
+						if ( elem.id !== match[2] ) {
+							return rootjQuery.find( selector );
+						}
+
+						// Otherwise, we inject the element directly into the jQuery object
+						this.length = 1;
+						this[0] = elem;
+					}
+
+					this.context = document;
+					this.selector = selector;
+					return this;
+				}
+
+			// HANDLE: $(expr, $(...))
+			} else if ( !context || context.jquery ) {
+				return ( context || rootjQuery ).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.context = this[0] = selector;
+			this.length = 1;
+			return this;
+
+		// HANDLE: $(function)
+		// Shortcut for document ready
+		} else if ( jQuery.isFunction( selector ) ) {
+			return rootjQuery.ready( selector );
+		}
+
+		if ( selector.selector !== undefined ) {
+			this.selector = selector.selector;
+			this.context = selector.context;
+		}
+
+		return jQuery.makeArray( selector, this );
+	},
+
+	// Start with an empty selector
+	selector: "",
+
+	// The default length of a jQuery object is 0
+	length: 0,
+
+	// The number of elements contained in the matched element set
+	size: function() {
+		return this.length;
+	},
+
+	toArray: function() {
+		return core_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 num == null ?
+
+			// Return a 'clean' array
+			this.toArray() :
+
+			// Return just the object
+			( num < 0 ? this[ this.length + num ] : 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;
+		ret.context = this.context;
+
+		// Return the newly-formed element set
+		return ret;
+	},
+
+	// Execute a callback for every element in the matched set.
+	// (You can seed the arguments with an array of args, but this is
+	// only used internally.)
+	each: function( callback, args ) {
+		return jQuery.each( this, callback, args );
+	},
+
+	ready: function( fn ) {
+		// Add the callback
+		jQuery.ready.promise().done( fn );
+
+		return this;
+	},
+
+	slice: function() {
+		return this.pushStack( core_slice.apply( this, arguments ) );
+	},
+
+	first: function() {
+		return this.eq( 0 );
+	},
+
+	last: function() {
+		return this.eq( -1 );
+	},
+
+	eq: function( i ) {
+		var len = this.length,
+			j = +i + ( i < 0 ? len : 0 );
+		return this.pushStack( j >= 0 && j < len ? [ this[j] ] : [] );
+	},
+
+	map: function( callback ) {
+		return this.pushStack( jQuery.map(this, function( elem, i ) {
+			return callback.call( elem, i, elem );
+		}));
+	},
+
+	end: function() {
+		return this.prevObject || this.constructor(null);
+	},
+
+	// For internal use only.
+	// Behaves like an Array's method, not like a jQuery method.
+	push: core_push,
+	sort: [].sort,
+	splice: [].splice
+};
+
+// Give the init function the jQuery prototype for later instantiation
+jQuery.fn.init.prototype = jQuery.fn;
+
+jQuery.extend = jQuery.fn.extend = function() {
+	var src, copyIsArray, copy, name, options, clone,
+		target = arguments[0] || {},
+		i = 1,
+		length = arguments.length,
+		deep = false;
+
+	// Handle a deep copy situation
+	if ( typeof target === "boolean" ) {
+		deep = target;
+		target = arguments[1] || {};
+		// skip the boolean and the target
+		i = 2;
+	}
+
+	// Handle case when target is a string or something (possible in deep copy)
+	if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
+		target = {};
+	}
+
+	// extend jQuery itself if only one argument is passed
+	if ( length === i ) {
+		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 ) {
+				src = target[ name ];
+				copy = options[ name ];
+
+				// Prevent never-ending loop
+				if ( target === copy ) {
+					continue;
+				}
+
+				// Recurse if we're merging plain objects or arrays
+				if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
+					if ( copyIsArray ) {
+						copyIsArray = false;
+						clone = src && jQuery.isArray(src) ? src : [];
+
+					} else {
+						clone = src && jQuery.isPlainObject(src) ? src : {};
+					}
+
+					// 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({
+	noConflict: function( deep ) {
+		if ( window.$ === jQuery ) {
+			window.$ = _$;
+		}
+
+		if ( deep && window.jQuery === jQuery ) {
+			window.jQuery = _jQuery;
+		}
+
+		return jQuery;
+	},
+
+	// 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 #6781
+	readyWait: 1,
+
+	// Hold (or release) the ready event
+	holdReady: function( hold ) {
+		if ( hold ) {
+			jQuery.readyWait++;
+		} else {
+			jQuery.ready( true );
+		}
+	},
+
+	// 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;
+		}
+
+		// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
+		if ( !document.body ) {
+			return setTimeout( jQuery.ready );
+		}
+
+		// 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 ] );
+
+		// Trigger any bound ready events
+		if ( jQuery.fn.trigger ) {
+			jQuery( document ).trigger("ready").off("ready");
+		}
+	},
+
+	// See test/unit/core.js for details concerning isFunction.
+	// Since version 1.3, DOM methods and functions like alert
+	// aren't supported. They return false on IE (#2968).
+	isFunction: function( obj ) {
+		return jQuery.type(obj) === "function";
+	},
+
+	isArray: Array.isArray || function( obj ) {
+		return jQuery.type(obj) === "array";
+	},
+
+	isWindow: function( obj ) {
+		return obj != null && obj == obj.window;
+	},
+
+	isNumeric: function( obj ) {
+		return !isNaN( parseFloat(obj) ) && isFinite( obj );
+	},
+
+	type: function( obj ) {
+		if ( obj == null ) {
+			return String( obj );
+		}
+		return typeof obj === "object" || typeof obj === "function" ?
+			class2type[ core_toString.call(obj) ] || "object" :
+			typeof obj;
+	},
+
+	isPlainObject: function( obj ) {
+		// Must be an Object.
+		// Because of IE, we also have to check the presence of the constructor property.
+		// Make sure that DOM nodes and window objects don't pass through, as well
+		if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
+			return false;
+		}
+
+		try {
+			// Not own constructor property must be Object
+			if ( obj.constructor &&
+				!core_hasOwn.call(obj, "constructor") &&
+				!core_hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
+				return false;
+			}
+		} catch ( e ) {
+			// IE8,9 Will throw exceptions on certain host objects #9897
+			return false;
+		}
+
+		// Own properties are enumerated firstly, so to speed up,
+		// if last one is own, then all properties are own.
+
+		var key;
+		for ( key in obj ) {}
+
+		return key === undefined || core_hasOwn.call( obj, key );
+	},
+
+	isEmptyObject: function( obj ) {
+		var name;
+		for ( name in obj ) {
+			return false;
+		}
+		return true;
+	},
+
+	error: function( msg ) {
+		throw new Error( msg );
+	},
+
+	// data: 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
+	parseHTML: function( data, context, keepScripts ) {
+		if ( !data || typeof data !== "string" ) {
+			return null;
+		}
+		if ( typeof context === "boolean" ) {
+			keepScripts = context;
+			context = false;
+		}
+		context = context || document;
+
+		var parsed = rsingleTag.exec( data ),
+			scripts = !keepScripts && [];
+
+		// Single tag
+		if ( parsed ) {
+			return [ context.createElement( parsed[1] ) ];
+		}
+
+		parsed = jQuery.buildFragment( [ data ], context, scripts );
+		if ( scripts ) {
+			jQuery( scripts ).remove();
+		}
+		return jQuery.merge( [], parsed.childNodes );
+	},
+
+	parseJSON: function( data ) {
+		// Attempt to parse using the native JSON parser first
+		if ( window.JSON && window.JSON.parse ) {
+			return window.JSON.parse( data );
+		}
+
+		if ( data === null ) {
+			return data;
+		}
+
+		if ( typeof data === "string" ) {
+
+			// Make sure leading/trailing whitespace is removed (IE can't handle it)
+			data = jQuery.trim( data );
+
+			if ( data ) {
+				// Make sure the incoming data is actual JSON
+				// Logic borrowed from http://json.org/json2.js
+				if ( rvalidchars.test( data.replace( rvalidescape, "@" )
+					.replace( rvalidtokens, "]" )
+					.replace( rvalidbraces, "")) ) {
+
+					return ( new Function( "return " + data ) )();
+				}
+			}
+		}
+
+		jQuery.error( "Invalid JSON: " + data );
+	},
+
+	// Cross-browser xml parsing
+	parseXML: function( data ) {
+		var xml, tmp;
+		if ( !data || typeof data !== "string" ) {
+			return null;
+		}
+		try {
+			if ( window.DOMParser ) { // Standard
+				tmp = new DOMParser();
+				xml = tmp.parseFromString( data , "text/xml" );
+			} else { // IE
+				xml = new ActiveXObject( "Microsoft.XMLDOM" );
+				xml.async = "false";
+				xml.loadXML( data );
+			}
+		} catch( e ) {
+			xml = undefined;
+		}
+		if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {
+			jQuery.error( "Invalid XML: " + data );
+		}
+		return xml;
+	},
+
+	noop: function() {},
+
+	// Evaluates a script in a global context
+	// Workarounds based on findings by Jim Driscoll
+	// http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
+	globalEval: function( data ) {
+		if ( data && jQuery.trim( data ) ) {
+			// We use execScript on Internet Explorer
+			// We use an anonymous function so that context is window
+			// rather than jQuery in Firefox
+			( window.execScript || function( data ) {
+				window[ "eval" ].call( window, data );
+			} )( data );
+		}
+	},
+
+	// Convert dashed to camelCase; used by the css and data modules
+	// Microsoft forgot to hump their vendor prefix (#9572)
+	camelCase: function( string ) {
+		return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
+	},
+
+	nodeName: function( elem, name ) {
+		return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
+	},
+
+	// args is for internal usage only
+	each: function( obj, callback, args ) {
+		var value,
+			i = 0,
+			length = obj.length,
+			isArray = isArraylike( obj );
+
+		if ( args ) {
+			if ( isArray ) {
+				for ( ; i < length; i++ ) {
+					value = callback.apply( obj[ i ], args );
+
+					if ( value === false ) {
+						break;
+					}
+				}
+			} else {
+				for ( i in obj ) {
+					value = callback.apply( obj[ i ], args );
+
+					if ( value === false ) {
+						break;
+					}
+				}
+			}
+
+		// A special, fast, case for the most common use of each
+		} else {
+			if ( isArray ) {
+				for ( ; i < length; i++ ) {
+					value = callback.call( obj[ i ], i, obj[ i ] );
+
+					if ( value === false ) {
+						break;
+					}
+				}
+			} else {
+				for ( i in obj ) {
+					value = callback.call( obj[ i ], i, obj[ i ] );
+
+					if ( value === false ) {
+						break;
+					}
+				}
+			}
+		}
+
+		return obj;
+	},
+
+	// Use native String.trim function wherever possible
+	trim: core_trim && !core_trim.call("\uFEFF\xA0") ?
+		function( text ) {
+			return text == null ?
+				"" :
+				core_trim.call( text );
+		} :
+
+		// Otherwise use our own trimming functionality
+		function( text ) {
+			return text == null ?
+				"" :
+				( text + "" ).replace( rtrim, "" );
+		},
+
+	// 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 {
+				core_push.call( ret, arr );
+			}
+		}
+
+		return ret;
+	},
+
+	inArray: function( elem, arr, i ) {
+		var len;
+
+		if ( arr ) {
+			if ( core_indexOf ) {
+				return core_indexOf.call( arr, elem, i );
+			}
+
+			len = arr.length;
+			i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;
+
+			for ( ; i < len; i++ ) {
+				// Skip accessing in sparse arrays
+				if ( i in arr && arr[ i ] === elem ) {
+					return i;
+				}
+			}
+		}
+
+		return -1;
+	},
+
+	merge: function( first, second ) {
+		var l = second.length,
+			i = first.length,
+			j = 0;
+
+		if ( typeof l === "number" ) {
+			for ( ; j < l; j++ ) {
+				first[ i++ ] = second[ j ];
+			}
+		} else {
+			while ( second[j] !== undefined ) {
+				first[ i++ ] = second[ j++ ];
+			}
+		}
+
+		first.length = i;
+
+		return first;
+	},
+
+	grep: function( elems, callback, inv ) {
+		var retVal,
+			ret = [],
+			i = 0,
+			length = elems.length;
+		inv = !!inv;
+
+		// Go through the array, only saving the items
+		// that pass the validator function
+		for ( ; i < length; i++ ) {
+			retVal = !!callback( elems[ i ], i );
+			if ( inv !== retVal ) {
+				ret.push( elems[ i ] );
+			}
+		}
+
+		return ret;
+	},
+
+	// arg is for internal usage only
+	map: function( elems, callback, arg ) {
+		var value,
+			i = 0,
+			length = elems.length,
+			isArray = isArraylike( elems ),
+			ret = [];
+
+		// Go through the array, translating each of the items to their
+		if ( isArray ) {
+			for ( ; i < length; i++ ) {
+				value = callback( elems[ i ], i, arg );
+
+				if ( value != null ) {
+					ret[ ret.length ] = value;
+				}
+			}
+
+		// Go through every key on the object,
+		} else {
+			for ( i in elems ) {
+				value = callback( elems[ i ], i, arg );
+
+				if ( value != null ) {
+					ret[ ret.length ] = value;
+				}
+			}
+		}
+
+		// Flatten any nested arrays
+		return core_concat.apply( [], ret );
+	},
+
+	// A global GUID counter for objects
+	guid: 1,
+
+	// Bind a function to a context, optionally partially applying any
+	// arguments.
+	proxy: function( fn, context ) {
+		var args, proxy, tmp;
+
+		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 ( !jQuery.isFunction( fn ) ) {
+			return undefined;
+		}
+
+		// Simulated bind
+		args = core_slice.call( arguments, 2 );
+		proxy = function() {
+			return fn.apply( context || this, args.concat( core_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;
+	},
+
+	// Multifunctional method to get and set values of a collection
+	// The value/s can optionally be executed if it's a function
+	access: function( elems, fn, key, value, chainable, emptyGet, raw ) {
+		var i = 0,
+			length = elems.length,
+			bulk = key == null;
+
+		// Sets many values
+		if ( jQuery.type( key ) === "object" ) {
+			chainable = true;
+			for ( i in key ) {
+				jQuery.access( elems, fn, i, key[i], true, emptyGet, raw );
+			}
+
+		// Sets one value
+		} else if ( value !== undefined ) {
+			chainable = true;
+
+			if ( !jQuery.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 < length; i++ ) {
+					fn( elems[i], key, raw ? value : value.call( elems[i], i, fn( elems[i], key ) ) );
+				}
+			}
+		}
+
+		return chainable ?
+			elems :
+
+			// Gets
+			bulk ?
+				fn.call( elems ) :
+				length ? fn( elems[0], key ) : emptyGet;
+	},
+
+	now: function() {
+		return ( new Date() ).getTime();
+	}
+});
+
+jQuery.ready.promise = function( obj ) {
+	if ( !readyList ) {
+
+		readyList = jQuery.Deferred();
+
+		// Catch cases where $(document).ready() is called after the browser event has already occurred.
+		// we once tried to use readyState "interactive" here, but it caused issues like the one
+		// discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15
+		if ( document.readyState === "complete" ) {
+			// Handle it asynchronously to allow scripts the opportunity to delay ready
+			setTimeout( jQuery.ready );
+
+		// Standards-based browsers support DOMContentLoaded
+		} else if ( document.addEventListener ) {
+			// Use the handy event callback
+			document.addEventListener( "DOMContentLoaded", completed, false );
+
+			// A fallback to window.onload, that will always work
+			window.addEventListener( "load", completed, false );
+
+		// If IE event model is used
+		} else {
+			// Ensure firing before onload, maybe late but safe also for iframes
+			document.attachEvent( "onreadystatechange", completed );
+
+			// A fallback to window.onload, that will always work
+			window.attachEvent( "onload", completed );
+
+			// If IE and not a frame
+			// continually check to see if the document is ready
+			var top = false;
+
+			try {
+				top = window.frameElement == null && document.documentElement;
+			} catch(e) {}
+
+			if ( top && top.doScroll ) {
+				(function doScrollCheck() {
+					if ( !jQuery.isReady ) {
+
+						try {
+							// Use the trick by Diego Perini
+							// http://javascript.nwbox.com/IEContentLoaded/
+							top.doScroll("left");
+						} catch(e) {
+							return setTimeout( doScrollCheck, 50 );
+						}
+
+						// detach all dom ready events
+						detach();
+
+						// and execute any waiting functions
+						jQuery.ready();
+					}
+				})();
+			}
+		}
+	}
+	return readyList.promise( obj );
+};
+
+// Populate the class2type map
+jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name) {
+	class2type[ "[object " + name + "]" ] = name.toLowerCase();
+});
+
+function isArraylike( obj ) {
+	var length = obj.length,
+		type = jQuery.type( obj );
+
+	if ( jQuery.isWindow( obj ) ) {
+		return false;
+	}
+
+	if ( obj.nodeType === 1 && length ) {
+		return true;
+	}
+
+	return type === "array" || type !== "function" &&
+		( length === 0 ||
+		typeof length === "number" && length > 0 && ( length - 1 ) in obj );
+}
+
+// All jQuery objects should point back to these
+rootjQuery = jQuery(document);
+// String to Object options format cache
+var optionsCache = {};
+
+// Convert String-formatted options into Object-formatted ones and store in cache
+function createOptions( options ) {
+	var object = optionsCache[ options ] = {};
+	jQuery.each( options.match( core_rnotwhite ) || [], 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" ?
+		( optionsCache[ options ] || 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,
+		// End of the loop when firing
+		firingLength,
+		// Index of currently firing callback (modified by remove if needed)
+		firingIndex,
+		// First callback to fire (used internally by add and fireWith)
+		firingStart,
+		// Actual callback list
+		list = [],
+		// Stack of fire calls for repeatable lists
+		stack = !options.once && [],
+		// Fire callbacks
+		fire = function( data ) {
+			memory = options.memory && data;
+			fired = true;
+			firingIndex = firingStart || 0;
+			firingStart = 0;
+			firingLength = list.length;
+			firing = true;
+			for ( ; list && firingIndex < firingLength; firingIndex++ ) {
+				if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) {
+					memory = false; // To prevent further calls using add
+					break;
+				}
+			}
+			firing = false;
+			if ( list ) {
+				if ( stack ) {
+					if ( stack.length ) {
+						fire( stack.shift() );
+					}
+				} else if ( memory ) {
+					list = [];
+				} else {
+					self.disable();
+				}
+			}
+		},
+		// Actual Callbacks object
+		self = {
+			// Add a callback or a collection of callbacks to the list
+			add: function() {
+				if ( list ) {
+					// First, we save the current length
+					var start = list.length;
+					(function add( args ) {
+						jQuery.each( args, function( _, arg ) {
+							var type = jQuery.type( arg );
+							if ( type === "function" ) {
+								if ( !options.unique || !self.has( arg ) ) {
+									list.push( arg );
+								}
+							} else if ( arg && arg.length && type !== "string" ) {
+								// Inspect recursively
+								add( arg );
+							}
+						});
+					})( arguments );
+					// Do we need to add the callbacks to the
+					// current firing batch?
+					if ( firing ) {
+						firingLength = list.length;
+					// With memory, if we're not firing then
+					// we should call right away
+					} else if ( memory ) {
+						firingStart = start;
+						fire( memory );
+					}
+				}
+				return this;
+			},
+			// Remove a callback from the list
+			remove: function() {
+				if ( list ) {
+					jQuery.each( arguments, function( _, arg ) {
+						var index;
+						while( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
+							list.splice( index, 1 );
+							// Handle firing indexes
+							if ( firing ) {
+								if ( index <= firingLength ) {
+									firingLength--;
+								}
+								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 && list.length );
+			},
+			// Remove all callbacks from the list
+			empty: function() {
+				list = [];
+				return this;
+			},
+			// Have the list do nothing anymore
+			disable: function() {
+				list = stack = memory = undefined;
+				return this;
+			},
+			// Is it disabled?
+			disabled: function() {
+				return !list;
+			},
+			// Lock the list in its current state
+			lock: function() {
+				stack = undefined;
+				if ( !memory ) {
+					self.disable();
+				}
+				return this;
+			},
+			// Is it locked?
+			locked: function() {
+				return !stack;
+			},
+			// Call all callbacks with the given context and arguments
+			fireWith: function( context, args ) {
+				args = args || [];
+				args = [ context, args.slice ? args.slice() : args ];
+				if ( list && ( !fired || stack ) ) {
+					if ( firing ) {
+						stack.push( args );
+					} else {
+						fire( args );
+					}
+				}
+				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;
+};
+jQuery.extend({
+
+	Deferred: function( func ) {
+		var tuples = [
+				// action, add listener, listener list, final state
+				[ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ],
+				[ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ],
+				[ "notify", "progress", jQuery.Callbacks("memory") ]
+			],
+			state = "pending",
+			promise = {
+				state: function() {
+					return state;
+				},
+				always: function() {
+					deferred.done( arguments ).fail( arguments );
+					return this;
+				},
+				then: function( /* fnDone, fnFail, fnProgress */ ) {
+					var fns = arguments;
+					return jQuery.Deferred(function( newDefer ) {
+						jQuery.each( tuples, function( i, tuple ) {
+							var action = tuple[ 0 ],
+								fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
+							// deferred[ done | fail | progress ] for forwarding actions to newDefer
+							deferred[ tuple[1] ](function() {
+								var returned = fn && fn.apply( this, arguments );
+								if ( returned && jQuery.isFunction( returned.promise ) ) {
+									returned.promise()
+										.done( newDefer.resolve )
+										.fail( newDefer.reject )
+										.progress( newDefer.notify );
+								} else {
+									newDefer[ action + "With" ]( this === promise ? newDefer.promise() : this, fn ? [ returned ] : arguments );
+								}
+							});
+						});
+						fns = null;
+					}).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 = {};
+
+		// Keep pipe for back-compat
+		promise.pipe = promise.then;
+
+		// Add list-specific methods
+		jQuery.each( tuples, function( i, tuple ) {
+			var list = tuple[ 2 ],
+				stateString = tuple[ 3 ];
+
+			// promise[ done | fail | progress ] = list.add
+			promise[ tuple[1] ] = list.add;
+
+			// Handle state
+			if ( stateString ) {
+				list.add(function() {
+					// state = [ resolved | rejected ]
+					state = stateString;
+
+				// [ reject_list | resolve_list ].disable; progress_list.lock
+				}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
+			}
+
+			// deferred[ resolve | reject | notify ]
+			deferred[ tuple[0] ] = function() {
+				deferred[ tuple[0] + "With" ]( this === deferred ? promise : this, arguments );
+				return this;
+			};
+			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( subordinate /* , ..., subordinateN */ ) {
+		var i = 0,
+			resolveValues = core_slice.call( arguments ),
+			length = resolveValues.length,
+
+			// the count of uncompleted subordinates
+			remaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,
+
+			// the master Deferred. If resolveValues consist of only a single Deferred, just use that.
+			deferred = remaining === 1 ? subordinate : jQuery.Deferred(),
+
+			// Update function for both resolve and progress values
+			updateFunc = function( i, contexts, values ) {
+				return function( value ) {
+					contexts[ i ] = this;
+					values[ i ] = arguments.length > 1 ? core_slice.call( arguments ) : value;
+					if( values === progressValues ) {
+						deferred.notifyWith( contexts, values );
+					} else if ( !( --remaining ) ) {
+						deferred.resolveWith( contexts, values );
+					}
+				};
+			},
+
+			progressValues, progressContexts, resolveContexts;
+
+		// add listeners to Deferred subordinates; treat others as resolved
+		if ( length > 1 ) {
+			progressValues = new Array( length );
+			progressContexts = new Array( length );
+			resolveContexts = new Array( length );
+			for ( ; i < length; i++ ) {
+				if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) {
+					resolveValues[ i ].promise()
+						.done( updateFunc( i, resolveContexts, resolveValues ) )
+						.fail( deferred.reject )
+						.progress( updateFunc( i, progressContexts, progressValues ) );
+				} else {
+					--remaining;
+				}
+			}
+		}
+
+		// if we're not waiting on anything, resolve the master
+		if ( !remaining ) {
+			deferred.resolveWith( resolveContexts, resolveValues );
+		}
+
+		return deferred.promise();
+	}
+});
+jQuery.support = (function() {
+
+	var support, all, a,
+		input, select, fragment,
+		opt, eventName, isSupported, i,
+		div = document.createElement("div");
+
+	// Setup
+	div.setAttribute( "className", "t" );
+	div.innerHTML = "  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>";
+
+	// Support tests won't run in some limited or non-browser environments
+	all = div.getElementsByTagName("*");
+	a = div.getElementsByTagName("a")[ 0 ];
+	if ( !all || !a || !all.length ) {
+		return {};
+	}
+
+	// First batch of tests
+	select = document.createElement("select");
+	opt = select.appendChild( document.createElement("option") );
+	input = div.getElementsByTagName("input")[ 0 ];
+
+	a.style.cssText = "top:1px;float:left;opacity:.5";
+	support = {
+		// Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
+		getSetAttribute: div.className !== "t",
+
+		// IE strips leading whitespace when .innerHTML is used
+		leadingWhitespace: div.firstChild.nodeType === 3,
+
+		// Make sure that tbody elements aren't automatically inserted
+		// IE will insert them into empty tables
+		tbody: !div.getElementsByTagName("tbody").length,
+
+		// Make sure that link elements get serialized correctly by innerHTML
+		// This requires a wrapper element in IE
+		htmlSerialize: !!div.getElementsByTagName("link").length,
+
+		// Get the style information from getAttribute
+		// (IE uses .cssText instead)
+		style: /top/.test( a.getAttribute("style") ),
+
+		// Make sure that URLs aren't manipulated
+		// (IE normalizes it by default)
+		hrefNormalized: a.getAttribute("href") === "/a",
+
+		// Make sure that element opacity exists
+		// (IE uses filter instead)
+		// Use a regex to work around a WebKit issue. See #5145
+		opacity: /^0.5/.test( a.style.opacity ),
+
+		// Verify style float existence
+		// (IE uses styleFloat instead of cssFloat)
+		cssFloat: !!a.style.cssFloat,
+
+		// Check the default checkbox/radio value ("" on WebKit; "on" elsewhere)
+		checkOn: !!input.value,
+
+		// Make sure that a selected-by-default option has a working selected property.
+		// (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
+		optSelected: opt.selected,
+
+		// Tests for enctype support on a form (#6743)
+		enctype: !!document.createElement("form").enctype,
+
+		// Makes sure cloning an html5 element does not cause problems
+		// Where outerHTML is undefined, this still works
+		html5Clone: document.createElement("nav").cloneNode( true ).outerHTML !== "<:nav></:nav>",
+
+		// jQuery.support.boxModel DEPRECATED in 1.8 since we don't support Quirks Mode
+		boxModel: document.compatMode === "CSS1Compat",
+
+		// Will be defined later
+		deleteExpando: true,
+		noCloneEvent: true,
+		inlineBlockNeedsLayout: false,
+		shrinkWrapBlocks: false,
+		reliableMarginRight: true,
+		boxSizingReliable: true,
+		pixelPosition: false
+	};
+
+	// Make sure checked status is properly cloned
+	input.checked = true;
+	support.noCloneChecked = input.cloneNode( true ).checked;
+
+	// Make sure that the options inside disabled selects aren't marked as disabled
+	// (WebKit marks them as disabled)
+	select.disabled = true;
+	support.optDisabled = !opt.disabled;
+
+	// Support: IE<9
+	try {
+		delete div.test;
+	} catch( e ) {
+		support.deleteExpando = false;
+	}
+
+	// Check if we can trust getAttribute("value")
+	input = document.createElement("input");
+	input.setAttribute( "value", "" );
+	support.input = input.getAttribute( "value" ) === "";
+
+	// Check if an input maintains its value after becoming a radio
+	input.value = "t";
+	input.setAttribute( "type", "radio" );
+	support.radioValue = input.value === "t";
+
+	// #11217 - WebKit loses check when the name is after the checked attribute
+	input.setAttribute( "checked", "t" );
+	input.setAttribute( "name", "t" );
+
+	fragment = document.createDocumentFragment();
+	fragment.appendChild( input );
+
+	// Check if a disconnected checkbox will retain its checked
+	// value of true after appended to the DOM (IE6/7)
+	support.appendChecked = input.checked;
+
+	// WebKit doesn't clone checked state correctly in fragments
+	support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
+
+	// Support: IE<9
+	// Opera does not clone events (and typeof div.attachEvent === undefined).
+	// IE9-10 clones events bound via attachEvent, but they don't trigger with .click()
+	if ( div.attachEvent ) {
+		div.attachEvent( "onclick", function() {
+			support.noCloneEvent = false;
+		});
+
+		div.cloneNode( true ).click();
+	}
+
+	// Support: IE<9 (lack submit/change bubble), Firefox 17+ (lack focusin event)
+	// Beware of CSP restrictions (https://developer.mozilla.org/en/Security/CSP), test/csp.php
+	for ( i in { submit: true, change: true, focusin: true }) {
+		div.setAttribute( eventName = "on" + i, "t" );
+
+		support[ i + "Bubbles" ] = eventName in window || div.attributes[ eventName ].expando === false;
+	}
+
+	div.style.backgroundClip = "content-box";
+	div.cloneNode( true ).style.backgroundClip = "";
+	support.clearCloneStyle = div.style.backgroundClip === "content-box";
+
+	// Run tests that need a body at doc ready
+	jQuery(function() {
+		var container, marginDiv, tds,
+			divReset = "padding:0;margin:0;border:0;display:block;box-sizing:content-box;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;",
+			body = document.getElementsByTagName("body")[0];
+
+		if ( !body ) {
+			// Return for frameset docs that don't have a body
+			return;
+		}
+
+		container = document.createElement("div");
+		container.style.cssText = "border:0;width:0;height:0;position:absolute;top:0;left:-9999px;margin-top:1px";
+
+		body.appendChild( container ).appendChild( div );
+
+		// Support: IE8
+		// Check if table cells still have offsetWidth/Height when they are set
+		// to display:none and there are still other visible table cells in a
+		// table row; if so, offsetWidth/Height are not reliable for use when
+		// determining if an element has been hidden directly using
+		// display:none (it is still safe to use offsets if a parent element is
+		// hidden; don safety goggles and see bug #4512 for more information).
+		div.innerHTML = "<table><tr><td></td><td>t</td></tr></table>";
+		tds = div.getElementsByTagName("td");
+		tds[ 0 ].style.cssText = "padding:0;margin:0;border:0;display:none";
+		isSupported = ( tds[ 0 ].offsetHeight === 0 );
+
+		tds[ 0 ].style.display = "";
+		tds[ 1 ].style.display = "none";
+
+		// Support: IE8
+		// Check if empty table cells still have offsetWidth/Height
+		support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
+
+		// Check box-sizing and margin behavior
+		div.innerHTML = "";
+		div.style.cssText = "box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%;";
+		support.boxSizing = ( div.offsetWidth === 4 );
+		support.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== 1 );
+
+		// Use window.getComputedStyle because jsdom on node.js will break without it.
+		if ( window.getComputedStyle ) {
+			support.pixelPosition = ( window.getComputedStyle( div, null ) || {} ).top !== "1%";
+			support.boxSizingReliable = ( window.getComputedStyle( div, null ) || { width: "4px" } ).width === "4px";
+
+			// Check if div with explicit width and no margin-right incorrectly
+			// gets computed margin-right based on width of container. (#3333)
+			// Fails in WebKit before Feb 2011 nightlies
+			// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
+			marginDiv = div.appendChild( document.createElement("div") );
+			marginDiv.style.cssText = div.style.cssText = divReset;
+			marginDiv.style.marginRight = marginDiv.style.width = "0";
+			div.style.width = "1px";
+
+			support.reliableMarginRight =
+				!parseFloat( ( window.getComputedStyle( marginDiv, null ) || {} ).marginRight );
+		}
+
+		if ( typeof div.style.zoom !== core_strundefined ) {
+			// Support: IE<8
+			// Check if natively block-level elements act like inline-block
+			// elements when setting their display to 'inline' and giving
+			// them layout
+			div.innerHTML = "";
+			div.style.cssText = divReset + "width:1px;padding:1px;display:inline;zoom:1";
+			support.inlineBlockNeedsLayout = ( div.offsetWidth === 3 );
+
+			// Support: IE6
+			// Check if elements with layout shrink-wrap their children
+			div.style.display = "block";
+			div.innerHTML = "<div></div>";
+			div.firstChild.style.width = "5px";
+			support.shrinkWrapBlocks = ( div.offsetWidth !== 3 );
+
+			if ( support.inlineBlockNeedsLayout ) {
+				// Prevent IE 6 from affecting layout for positioned elements #11048
+				// Prevent IE from shrinking the body in IE 7 mode #12869
+				// Support: IE<8
+				body.style.zoom = 1;
+			}
+		}
+
+		body.removeChild( container );
+
+		// Null elements to avoid leaks in IE
+		container = div = tds = marginDiv = null;
+	});
+
+	// Null elements to avoid leaks in IE
+	all = select = fragment = opt = a = input = null;
+
+	return support;
+})();
+
+var rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/,
+	rmultiDash = /([A-Z])/g;
+
+function internalData( elem, name, data, pvt /* Internal Use Only */ ){
+	if ( !jQuery.acceptData( elem ) ) {
+		return;
+	}
+
+	var thisCache, ret,
+		internalKey = jQuery.expando,
+		getByName = typeof name === "string",
+
+		// We have to handle DOM nodes and JS objects differently because IE6-7
+		// can't GC object references properly across the DOM-JS boundary
+		isNode = elem.nodeType,
+
+		// Only DOM nodes need the global jQuery cache; JS object data is
+		// attached directly to the object so GC can occur automatically
+		cache = isNode ? jQuery.cache : elem,
+
+		// Only defining an ID for JS objects if its cache already exists allows
+		// the code to shortcut on the same path as a DOM node with no cache
+		id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey;
+
+	// Avoid doing any more work than we need to when trying to get data on an
+	// object that has no data at all
+	if ( (!id || !cache[id] || (!pvt && !cache[id].data)) && getByName && data === undefined ) {
+		return;
+	}
+
+	if ( !id ) {
+		// Only DOM nodes need a new unique ID for each element since their data
+		// ends up in the global cache
+		if ( isNode ) {
+			elem[ internalKey ] = id = core_deletedIds.pop() || jQuery.guid++;
+		} else {
+			id = internalKey;
+		}
+	}
+
+	if ( !cache[ id ] ) {
+		cache[ id ] = {};
+
+		// Avoids exposing jQuery metadata on plain JS objects when the object
+		// is serialized using JSON.stringify
+		if ( !isNode ) {
+			cache[ id ].toJSON = jQuery.noop;
+		}
+	}
+
+	// An object can be passed to jQuery.data instead of a key/value pair; this gets
+	// shallow copied over onto the existing cache
+	if ( typeof name === "object" || typeof name === "function" ) {
+		if ( pvt ) {
+			cache[ id ] = jQuery.extend( cache[ id ], name );
+		} else {
+			cache[ id ].data = jQuery.extend( cache[ id ].data, name );
+		}
+	}
+
+	thisCache = cache[ id ];
+
+	// jQuery data() is stored in a separate object inside the object's internal data
+	// cache in order to avoid key collisions between internal data and user-defined
+	// data.
+	if ( !pvt ) {
+		if ( !thisCache.data ) {
+			thisCache.data = {};
+		}
+
+		thisCache = thisCache.data;
+	}
+
+	if ( data !== undefined ) {
+		thisCache[ jQuery.camelCase( name ) ] = data;
+	}
+
+	// Check for both converted-to-camel and non-converted data property names
+	// If a data property was specified
+	if ( getByName ) {
+
+		// First Try to find as-is property data
+		ret = thisCache[ name ];
+
+		// Test for null|undefined property data
+		if ( ret == null ) {
+
+			// Try to find the camelCased property
+			ret = thisCache[ jQuery.camelCase( name ) ];
+		}
+	} else {
+		ret = thisCache;
+	}
+
+	return ret;
+}
+
+function internalRemoveData( elem, name, pvt ) {
+	if ( !jQuery.acceptData( elem ) ) {
+		return;
+	}
+
+	var i, l, thisCache,
+		isNode = elem.nodeType,
+
+		// See jQuery.data for more information
+		cache = isNode ? jQuery.cache : elem,
+		id = isNode ? elem[ jQuery.expando ] : jQuery.expando;
+
+	// If there is already no cache entry for this object, there is no
+	// purpose in continuing
+	if ( !cache[ id ] ) {
+		return;
+	}
+
+	if ( name ) {
+
+		thisCache = pvt ? cache[ id ] : cache[ id ].data;
+
+		if ( thisCache ) {
+
+			// Support array or space separated string names for data keys
+			if ( !jQuery.isArray( name ) ) {
+
+				// try the string as a key before any manipulation
+				if ( name in thisCache ) {
+					name = [ name ];
+				} else {
+
+					// split the camel cased version by spaces unless a key with the spaces exists
+					name = jQuery.camelCase( name );
+					if ( name in thisCache ) {
+						name = [ name ];
+					} else {
+						name = name.split(" ");
+					}
+				}
+			} else {
+				// If "name" is an array of keys...
+				// When data is initially created, via ("key", "val") signature,
+				// keys will be converted to camelCase.
+				// Since there is no way to tell _how_ a key was added, remove
+				// both plain key and camelCase key. #12786
+				// This will only penalize the array argument path.
+				name = name.concat( jQuery.map( name, jQuery.camelCase ) );
+			}
+
+			for ( i = 0, l = name.length; i < l; i++ ) {
+				delete thisCache[ name[i] ];
+			}
+
+			// If there is no data left in the cache, we want to continue
+			// and let the cache object itself get destroyed
+			if ( !( pvt ? isEmptyDataObject : jQuery.isEmptyObject )( thisCache ) ) {
+				return;
+			}
+		}
+	}
+
+	// See jQuery.data for more information
+	if ( !pvt ) {
+		delete cache[ id ].data;
+
+		// Don't destroy the parent cache unless the internal data object
+		// had been the only thing left in it
+		if ( !isEmptyDataObject( cache[ id ] ) ) {
+			return;
+		}
+	}
+
+	// Destroy the cache
+	if ( isNode ) {
+		jQuery.cleanData( [ elem ], true );
+
+	// Use delete when supported for expandos or `cache` is not a window per isWindow (#10080)
+	} else if ( jQuery.support.deleteExpando || cache != cache.window ) {
+		delete cache[ id ];
+
+	// When all else fails, null
+	} else {
+		cache[ id ] = null;
+	}
+}
+
+jQuery.extend({
+	cache: {},
+
+	// Unique for each copy of jQuery on the page
+	// Non-digits removed to match rinlinejQuery
+	expando: "jQuery" + ( core_version + Math.random() ).replace( /\D/g, "" ),
+
+	// The following elements throw uncatchable exceptions if you
+	// attempt to add expando properties to them.
+	noData: {
+		"embed": true,
+		// Ban all objects except for Flash (which handle expandos)
+		"object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
+		"applet": true
+	},
+
+	hasData: function( elem ) {
+		elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
+		return !!elem && !isEmptyDataObject( elem );
+	},
+
+	data: function( elem, name, data ) {
+		return internalData( elem, name, data );
+	},
+
+	removeData: function( elem, name ) {
+		return internalRemoveData( elem, name );
+	},
+
+	// For internal use only.
+	_data: function( elem, name, data ) {
+		return internalData( elem, name, data, true );
+	},
+
+	_removeData: function( elem, name ) {
+		return internalRemoveData( elem, name, true );
+	},
+
+	// A method for determining if a DOM node can handle the data expando
+	acceptData: function( elem ) {
+		// Do not set data on non-element because it will not be cleared (#8335).
+		if ( elem.nodeType && elem.nodeType !== 1 && elem.nodeType !== 9 ) {
+			return false;
+		}
+
+		var noData = elem.nodeName && jQuery.noData[ elem.nodeName.toLowerCase() ];
+
+		// nodes accept data unless otherwise specified; rejection can be conditional
+		return !noData || noData !== true && elem.getAttribute("classid") === noData;
+	}
+});
+
+jQuery.fn.extend({
+	data: function( key, value ) {
+		var attrs, name,
+			elem = this[0],
+			i = 0,
+			data = null;
+
+		// Gets all values
+		if ( key === undefined ) {
+			if ( this.length ) {
+				data = jQuery.data( elem );
+
+				if ( elem.nodeType === 1 && !jQuery._data( elem, "parsedAttrs" ) ) {
+					attrs = elem.attributes;
+					for ( ; i < attrs.length; i++ ) {
+						name = attrs[i].name;
+
+						if ( !name.indexOf( "data-" ) ) {
+							name = jQuery.camelCase( name.slice(5) );
+
+							dataAttr( elem, name, data[ name ] );
+						}
+					}
+					jQuery._data( elem, "parsedAttrs", true );
+				}
+			}
+
+			return data;
+		}
+
+		// Sets multiple values
+		if ( typeof key === "object" ) {
+			return this.each(function() {
+				jQuery.data( this, key );
+			});
+		}
+
+		return jQuery.access( this, function( value ) {
+
+			if ( value === undefined ) {
+				// Try to fetch any internally stored data first
+				return elem ? dataAttr( elem, key, jQuery.data( elem, key ) ) : null;
+			}
+
+			this.each(function() {
+				jQuery.data( this, key, value );
+			});
+		}, null, value, arguments.length > 1, null, true );
+	},
+
+	removeData: function( key ) {
+		return this.each(function() {
+			jQuery.removeData( this, key );
+		});
+	}
+});
+
+function dataAttr( elem, key, data ) {
+	// If nothing was found internally, try to fetch any
+	// data from the HTML5 data-* attribute
+	if ( data === undefined && elem.nodeType === 1 ) {
+
+		var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase();
+
+		data = elem.getAttribute( name );
+
+		if ( typeof data === "string" ) {
+			try {
+				data = data === "true" ? true :
+					data === "false" ? false :
+					data === "null" ? null :
+					// Only convert to a number if it doesn't change the string
+					+data + "" === data ? +data :
+					rbrace.test( data ) ? jQuery.parseJSON( data ) :
+						data;
+			} catch( e ) {}
+
+			// Make sure we set the data so it isn't changed later
+			jQuery.data( elem, key, data );
+
+		} else {
+			data = undefined;
+		}
+	}
+
+	return data;
+}
+
+// checks a cache object for emptiness
+function isEmptyDataObject( obj ) {
+	var name;
+	for ( name in obj ) {
+
+		// if the public data object is empty, the private is still empty
+		if ( name === "data" && jQuery.isEmptyObject( obj[name] ) ) {
+			continue;
+		}
+		if ( name !== "toJSON" ) {
+			return false;
+		}
+	}
+
+	return true;
+}
+jQuery.extend({
+	queue: function( elem, type, data ) {
+		var queue;
+
+		if ( elem ) {
+			type = ( type || "fx" ) + "queue";
+			queue = jQuery._data( elem, type );
+
+			// Speed up dequeue by getting out quickly if this is just a lookup
+			if ( data ) {
+				if ( !queue || jQuery.isArray(data) ) {
+					queue = jQuery._data( 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--;
+		}
+
+		hooks.cur = fn;
+		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 intended for public consumption - generates a queueHooks object, or returns the current one
+	_queueHooks: function( elem, type ) {
+		var key = type + "queueHooks";
+		return jQuery._data( elem, key ) || jQuery._data( elem, key, {
+			empty: jQuery.Callbacks("once memory").add(function() {
+				jQuery._removeData( elem, type + "queue" );
+				jQuery._removeData( elem, 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 );
+		});
+	},
+	// Based off of the plugin by Clint Helfers, with permission.
+	// http://blindsignals.com/index.php/2009/07/jquery-delay/
+	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 = setTimeout( next, time );
+			hooks.stop = function() {
+				clearTimeout( timeout );
+			};
+		});
+	},
+	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 = jQuery._data( elements[ i ], type + "queueHooks" );
+			if ( tmp && tmp.empty ) {
+				count++;
+				tmp.empty.add( resolve );
+			}
+		}
+		resolve();
+		return defer.promise( obj );
+	}
+});
+var nodeHook, boolHook,
+	rclass = /[\t\r\n]/g,
+	rreturn = /\r/g,
+	rfocusable = /^(?:input|select|textarea|button|object)$/i,
+	rclickable = /^(?:a|area)$/i,
+	rboolean = /^(?:checked|selected|autofocus|autoplay|async|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped)$/i,
+	ruseDefault = /^(?:checked|selected)$/i,
+	getSetAttribute = jQuery.support.getSetAttribute,
+	getSetInput = jQuery.support.input;
+
+jQuery.fn.extend({
+	attr: function( name, value ) {
+		return jQuery.access( this, jQuery.attr, name, value, arguments.length > 1 );
+	},
+
+	removeAttr: function( name ) {
+		return this.each(function() {
+			jQuery.removeAttr( this, name );
+		});
+	},
+
+	prop: function( name, value ) {
+		return jQuery.access( this, jQuery.prop, name, value, arguments.length > 1 );
+	},
+
+	removeProp: function( name ) {
+		name = jQuery.propFix[ name ] || name;
+		return this.each(function() {
+			// try/catch handles cases where IE balks (such as removing a property on window)
+			try {
+				this[ name ] = undefined;
+				delete this[ name ];
+			} catch( e ) {}
+		});
+	},
+
+	addClass: function( value ) {
+		var classes, elem, cur, clazz, j,
+			i = 0,
+			len = this.length,
+			proceed = typeof value === "string" && value;
+
+		if ( jQuery.isFunction( value ) ) {
+			return this.each(function( j ) {
+				jQuery( this ).addClass( value.call( this, j, this.className ) );
+			});
+		}
+
+		if ( proceed ) {
+			// The disjunction here is for better compressibility (see removeClass)
+			classes = ( value || "" ).match( core_rnotwhite ) || [];
+
+			for ( ; i < len; i++ ) {
+				elem = this[ i ];
+				cur = elem.nodeType === 1 && ( elem.className ?
+					( " " + elem.className + " " ).replace( rclass, " " ) :
+					" "
+				);
+
+				if ( cur ) {
+					j = 0;
+					while ( (clazz = classes[j++]) ) {
+						if ( cur.indexOf( " " + clazz + " " ) < 0 ) {
+							cur += clazz + " ";
+						}
+					}
+					elem.className = jQuery.trim( cur );
+
+				}
+			}
+		}
+
+		return this;
+	},
+
+	removeClass: function( value ) {
+		var classes, elem, cur, clazz, j,
+			i = 0,
+			len = this.length,
+			proceed = arguments.length === 0 || typeof value === "string" && value;
+
+		if ( jQuery.isFunction( value ) ) {
+			return this.each(function( j ) {
+				jQuery( this ).removeClass( value.call( this, j, this.className ) );
+			});
+		}
+		if ( proceed ) {
+			classes = ( value || "" ).match( core_rnotwhite ) || [];
+
+			for ( ; i < len; i++ ) {
+				elem = this[ i ];
+				// This expression is here for better compressibility (see addClass)
+				cur = elem.nodeType === 1 && ( elem.className ?
+					( " " + elem.className + " " ).replace( rclass, " " ) :
+					""
+				);
+
+				if ( cur ) {
+					j = 0;
+					while ( (clazz = classes[j++]) ) {
+						// Remove *all* instances
+						while ( cur.indexOf( " " + clazz + " " ) >= 0 ) {
+							cur = cur.replace( " " + clazz + " ", " " );
+						}
+					}
+					elem.className = value ? jQuery.trim( cur ) : "";
+				}
+			}
+		}
+
+		return this;
+	},
+
+	toggleClass: function( value, stateVal ) {
+		var type = typeof value,
+			isBool = typeof stateVal === "boolean";
+
+		if ( jQuery.isFunction( value ) ) {
+			return this.each(function( i ) {
+				jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal );
+			});
+		}
+
+		return this.each(function() {
+			if ( type === "string" ) {
+				// toggle individual class names
+				var className,
+					i = 0,
+					self = jQuery( this ),
+					state = stateVal,
+					classNames = value.match( core_rnotwhite ) || [];
+
+				while ( (className = classNames[ i++ ]) ) {
+					// check each className given, space separated list
+					state = isBool ? state : !self.hasClass( className );
+					self[ state ? "addClass" : "removeClass" ]( className );
+				}
+
+			// Toggle whole class name
+			} else if ( type === core_strundefined || type === "boolean" ) {
+				if ( this.className ) {
+					// store className if set
+					jQuery._data( this, "__className__", this.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.
+				this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
+			}
+		});
+	},
+
+	hasClass: function( selector ) {
+		var className = " " + selector + " ",
+			i = 0,
+			l = this.length;
+		for ( ; i < l; i++ ) {
+			if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) >= 0 ) {
+				return true;
+			}
+		}
+
+		return false;
+	},
+
+	val: function( value ) {
+		var ret, hooks, isFunction,
+			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;
+
+				return typeof ret === "string" ?
+					// handle most common string cases
+					ret.replace(rreturn, "") :
+					// handle cases where value is null/undef or number
+					ret == null ? "" : ret;
+			}
+
+			return;
+		}
+
+		isFunction = jQuery.isFunction( value );
+
+		return this.each(function( i ) {
+			var val,
+				self = jQuery(this);
+
+			if ( this.nodeType !== 1 ) {
+				return;
+			}
+
+			if ( isFunction ) {
+				val = value.call( this, i, self.val() );
+			} else {
+				val = value;
+			}
+
+			// Treat null/undefined as ""; convert numbers to string
+			if ( val == null ) {
+				val = "";
+			} else if ( typeof val === "number" ) {
+				val += "";
+			} else if ( jQuery.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 ) {
+				// attributes.value is undefined in Blackberry 4.7 but
+				// uses .value. See #6932
+				var val = elem.attributes.value;
+				return !val || val.specified ? elem.value : elem.text;
+			}
+		},
+		select: {
+			get: function( elem ) {
+				var value, option,
+					options = elem.options,
+					index = elem.selectedIndex,
+					one = elem.type === "select-one" || index < 0,
+					values = one ? null : [],
+					max = one ? index + 1 : options.length,
+					i = index < 0 ?
+						max :
+						one ? index : 0;
+
+				// Loop through all the selected options
+				for ( ; i < max; i++ ) {
+					option = options[ i ];
+
+					// oldIE doesn't update selected after form reset (#2551)
+					if ( ( option.selected || i === index ) &&
+							// Don't return options that are disabled or in a disabled optgroup
+							( jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null ) &&
+							( !option.parentNode.disabled || !jQuery.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 values = jQuery.makeArray( value );
+
+				jQuery(elem).find("option").each(function() {
+					this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
+				});
+
+				if ( !values.length ) {
+					elem.selectedIndex = -1;
+				}
+				return values;
+			}
+		}
+	},
+
+	attr: function( elem, name, value ) {
+		var hooks, notxml, ret,
+			nType = elem.nodeType;
+
+		// don't get/set attributes on text, comment and attribute nodes
+		if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
+			return;
+		}
+
+		// Fallback to prop when attributes are not supported
+		if ( typeof elem.getAttribute === core_strundefined ) {
+			return jQuery.prop( elem, name, value );
+		}
+
+		notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
+
+		// All attributes are lowercase
+		// Grab necessary hook if one is defined
+		if ( notxml ) {
+			name = name.toLowerCase();
+			hooks = jQuery.attrHooks[ name ] || ( rboolean.test( name ) ? boolHook : nodeHook );
+		}
+
+		if ( value !== undefined ) {
+
+			if ( value === null ) {
+				jQuery.removeAttr( elem, name );
+
+			} else if ( hooks && notxml && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
+				return ret;
+
+			} else {
+				elem.setAttribute( name, value + "" );
+				return value;
+			}
+
+		} else if ( hooks && notxml && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
+			return ret;
+
+		} else {
+
+			// In IE9+, Flash objects don't have .getAttribute (#12945)
+			// Support: IE9+
+			if ( typeof elem.getAttribute !== core_strundefined ) {
+				ret =  elem.getAttribute( name );
+			}
+
+			// Non-existent attributes return null, we normalize to undefined
+			return ret == null ?
+				undefined :
+				ret;
+		}
+	},
+
+	removeAttr: function( elem, value ) {
+		var name, propName,
+			i = 0,
+			attrNames = value && value.match( core_rnotwhite );
+
+		if ( attrNames && elem.nodeType === 1 ) {
+			while ( (name = attrNames[i++]) ) {
+				propName = jQuery.propFix[ name ] || name;
+
+				// Boolean attributes get special treatment (#10870)
+				if ( rboolean.test( name ) ) {
+					// Set corresponding property to false for boolean attributes
+					// Also clear defaultChecked/defaultSelected (if appropriate) for IE<8
+					if ( !getSetAttribute && ruseDefault.test( name ) ) {
+						elem[ jQuery.camelCase( "default-" + name ) ] =
+							elem[ propName ] = false;
+					} else {
+						elem[ propName ] = false;
+					}
+
+				// See #9699 for explanation of this approach (setting first, then removal)
+				} else {
+					jQuery.attr( elem, name, "" );
+				}
+
+				elem.removeAttribute( getSetAttribute ? name : propName );
+			}
+		}
+	},
+
+	attrHooks: {
+		type: {
+			set: function( elem, value ) {
+				if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) {
+					// Setting the type on a radio button after the value resets the value in IE6-9
+					// Reset value to default in case type is set after value during creation
+					var val = elem.value;
+					elem.setAttribute( "type", value );
+					if ( val ) {
+						elem.value = val;
+					}
+					return value;
+				}
+			}
+		}
+	},
+
+	propFix: {
+		tabindex: "tabIndex",
+		readonly: "readOnly",
+		"for": "htmlFor",
+		"class": "className",
+		maxlength: "maxLength",
+		cellspacing: "cellSpacing",
+		cellpadding: "cellPadding",
+		rowspan: "rowSpan",
+		colspan: "colSpan",
+		usemap: "useMap",
+		frameborder: "frameBorder",
+		contenteditable: "contentEditable"
+	},
+
+	prop: function( elem, name, value ) {
+		var ret, hooks, notxml,
+			nType = elem.nodeType;
+
+		// don't get/set properties on text, comment and attribute nodes
+		if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
+			return;
+		}
+
+		notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
+
+		if ( notxml ) {
+			// 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;
+
+			} else {
+				return ( elem[ name ] = value );
+			}
+
+		} else {
+			if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
+				return ret;
+
+			} else {
+				return elem[ name ];
+			}
+		}
+	},
+
+	propHooks: {
+		tabIndex: {
+			get: function( elem ) {
+				// elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
+				// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
+				var attributeNode = elem.getAttributeNode("tabindex");
+
+				return attributeNode && attributeNode.specified ?
+					parseInt( attributeNode.value, 10 ) :
+					rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
+						0 :
+						undefined;
+			}
+		}
+	}
+});
+
+// Hook for boolean attributes
+boolHook = {
+	get: function( elem, name ) {
+		var
+			// Use .prop to determine if this attribute is understood as boolean
+			prop = jQuery.prop( elem, name ),
+
+			// Fetch it accordingly
+			attr = typeof prop === "boolean" && elem.getAttribute( name ),
+			detail = typeof prop === "boolean" ?
+
+				getSetInput && getSetAttribute ?
+					attr != null :
+					// oldIE fabricates an empty string for missing boolean attributes
+					// and conflates checked/selected into attroperties
+					ruseDefault.test( name ) ?
+						elem[ jQuery.camelCase( "default-" + name ) ] :
+						!!attr :
+
+				// fetch an attribute node for properties not recognized as boolean
+				elem.getAttributeNode( name );
+
+		return detail && detail.value !== false ?
+			name.toLowerCase() :
+			undefined;
+	},
+	set: function( elem, value, name ) {
+		if ( value === false ) {
+			// Remove boolean attributes when set to false
+			jQuery.removeAttr( elem, name );
+		} else if ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) {
+			// IE<8 needs the *property* name
+			elem.setAttribute( !getSetAttribute && jQuery.propFix[ name ] || name, name );
+
+		// Use defaultChecked and defaultSelected for oldIE
+		} else {
+			elem[ jQuery.camelCase( "default-" + name ) ] = elem[ name ] = true;
+		}
+
+		return name;
+	}
+};
+
+// fix oldIE value attroperty
+if ( !getSetInput || !getSetAttribute ) {
+	jQuery.attrHooks.value = {
+		get: function( elem, name ) {
+			var ret = elem.getAttributeNode( name );
+			return jQuery.nodeName( elem, "input" ) ?
+
+				// Ignore the value *property* by using defaultValue
+				elem.defaultValue :
+
+				ret && ret.specified ? ret.value : undefined;
+		},
+		set: function( elem, value, name ) {
+			if ( jQuery.nodeName( elem, "input" ) ) {
+				// Does not return so that setAttribute is also used
+				elem.defaultValue = value;
+			} else {
+				// Use nodeHook if defined (#1954); otherwise setAttribute is fine
+				return nodeHook && nodeHook.set( elem, value, name );
+			}
+		}
+	};
+}
+
+// IE6/7 do not support getting/setting some attributes with get/setAttribute
+if ( !getSetAttribute ) {
+
+	// Use this for any attribute in IE6/7
+	// This fixes almost every IE6/7 issue
+	nodeHook = jQuery.valHooks.button = {
+		get: function( elem, name ) {
+			var ret = elem.getAttributeNode( name );
+			return ret && ( name === "id" || name === "name" || name === "coords" ? ret.value !== "" : ret.specified ) ?
+				ret.value :
+				undefined;
+		},
+		set: function( elem, value, name ) {
+			// Set the existing or create a new attribute node
+			var ret = elem.getAttributeNode( name );
+			if ( !ret ) {
+				elem.setAttributeNode(
+					(ret = elem.ownerDocument.createAttribute( name ))
+				);
+			}
+
+			ret.value = value += "";
+
+			// Break association with cloned elements by also using setAttribute (#9646)
+			return name === "value" || value === elem.getAttribute( name ) ?
+				value :
+				undefined;
+		}
+	};
+
+	// Set contenteditable to false on removals(#10429)
+	// Setting to empty string throws an error as an invalid value
+	jQuery.attrHooks.contenteditable = {
+		get: nodeHook.get,
+		set: function( elem, value, name ) {
+			nodeHook.set( elem, value === "" ? false : value, name );
+		}
+	};
+
+	// Set width and height to auto instead of 0 on empty string( Bug #8150 )
+	// This is for removals
+	jQuery.each([ "width", "height" ], function( i, name ) {
+		jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
+			set: function( elem, value ) {
+				if ( value === "" ) {
+					elem.setAttribute( name, "auto" );
+					return value;
+				}
+			}
+		});
+	});
+}
+
+
+// Some attributes require a special call on IE
+// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
+if ( !jQuery.support.hrefNormalized ) {
+	jQuery.each([ "href", "src", "width", "height" ], function( i, name ) {
+		jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
+			get: function( elem ) {
+				var ret = elem.getAttribute( name, 2 );
+				return ret == null ? undefined : ret;
+			}
+		});
+	});
+
+	// href/src property should get the full normalized URL (#10299/#12915)
+	jQuery.each([ "href", "src" ], function( i, name ) {
+		jQuery.propHooks[ name ] = {
+			get: function( elem ) {
+				return elem.getAttribute( name, 4 );
+			}
+		};
+	});
+}
+
+if ( !jQuery.support.style ) {
+	jQuery.attrHooks.style = {
+		get: function( elem ) {
+			// Return undefined in the case of empty string
+			// Note: IE uppercases css property names, but if we were to .toLowerCase()
+			// .cssText, that would destroy case senstitivity in URL's, like in "background"
+			return elem.style.cssText || undefined;
+		},
+		set: function( elem, value ) {
+			return ( elem.style.cssText = value + "" );
+		}
+	};
+}
+
+// Safari mis-reports the default selected property of an option
+// Accessing the parent's selectedIndex property fixes it
+if ( !jQuery.support.optSelected ) {
+	jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, {
+		get: function( elem ) {
+			var parent = elem.parentNode;
+
+			if ( parent ) {
+				parent.selectedIndex;
+
+				// Make sure that it also works with optgroups, see #5701
+				if ( parent.parentNode ) {
+					parent.parentNode.selectedIndex;
+				}
+			}
+			return null;
+		}
+	});
+}
+
+// IE6/7 call enctype encoding
+if ( !jQuery.support.enctype ) {
+	jQuery.propFix.enctype = "encoding";
+}
+
+// Radios and checkboxes getter/setter
+if ( !jQuery.support.checkOn ) {
+	jQuery.each([ "radio", "checkbox" ], function() {
+		jQuery.valHooks[ this ] = {
+			get: function( elem ) {
+				// Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
+				return elem.getAttribute("value") === null ? "on" : elem.value;
+			}
+		};
+	});
+}
+jQuery.each([ "radio", "checkbox" ], function() {
+	jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], {
+		set: function( elem, value ) {
+			if ( jQuery.isArray( value ) ) {
+				return ( elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0 );
+			}
+		}
+	});
+});
+var rformElems = /^(?:input|select|textarea)$/i,
+	rkeyEvent = /^key/,
+	rmouseEvent = /^(?:mouse|contextmenu)|click/,
+	rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
+	rtypenamespace = /^([^.]*)(?:\.(.+)|)$/;
+
+function returnTrue() {
+	return true;
+}
+
+function returnFalse() {
+	return false;
+}
+
+/*
+ * 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 tmp, events, t, handleObjIn,
+			special, eventHandle, handleObj,
+			handlers, type, namespaces, origType,
+			elemData = jQuery._data( elem );
+
+		// Don't attach events to noData or text/comment nodes (but allow plain objects)
+		if ( !elemData ) {
+			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;
+		}
+
+		// 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 = {};
+		}
+		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 !== core_strundefined && (!e || jQuery.event.triggered !== e.type) ?
+					jQuery.event.dispatch.apply( eventHandle.elem, arguments ) :
+					undefined;
+			};
+			// Add elem as a property of the handle fn to prevent a memory leak with IE non-native events
+			eventHandle.elem = elem;
+		}
+
+		// Handle multiple events separated by a space
+		// jQuery(...).bind("mouseover mouseout", fn);
+		types = ( types || "" ).match( core_rnotwhite ) || [""];
+		t = types.length;
+		while ( t-- ) {
+			tmp = rtypenamespace.exec( types[t] ) || [];
+			type = origType = tmp[1];
+			namespaces = ( tmp[2] || "" ).split( "." ).sort();
+
+			// 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/attachEvent if the special events handler returns false
+				if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
+					// Bind the global event handler to the element
+					if ( elem.addEventListener ) {
+						elem.addEventListener( type, eventHandle, false );
+
+					} else if ( elem.attachEvent ) {
+						elem.attachEvent( "on" + 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;
+		}
+
+		// Nullify elem to prevent memory leaks in IE
+		elem = null;
+	},
+
+	// Detach an event or set of events from an element
+	remove: function( elem, types, handler, selector, mappedTypes ) {
+		var j, handleObj, tmp,
+			origCount, t, events,
+			special, handlers, type,
+			namespaces, origType,
+			elemData = jQuery.hasData( elem ) && jQuery._data( elem );
+
+		if ( !elemData || !(events = elemData.events) ) {
+			return;
+		}
+
+		// Once for each type.namespace in types; type may be omitted
+		types = ( types || "" ).match( core_rnotwhite ) || [""];
+		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 the expando if it's no longer used
+		if ( jQuery.isEmptyObject( events ) ) {
+			delete elemData.handle;
+
+			// removeData also checks for emptiness and clears the expando if empty
+			// so use it instead of delete
+			jQuery._removeData( elem, "events" );
+		}
+	},
+
+	trigger: function( event, data, elem, onlyHandlers ) {
+		var handle, ontype, cur,
+			bubbleType, special, tmp, i,
+			eventPath = [ elem || document ],
+			type = core_hasOwn.call( event, "type" ) ? event.type : event,
+			namespaces = core_hasOwn.call( event, "namespace" ) ? event.namespace.split(".") : [];
+
+		cur = 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(".") >= 0 ) {
+			// 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 );
+
+		event.isTrigger = true;
+		event.namespace = namespaces.join(".");
+		event.namespace_re = 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 (#9951)
+		// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
+		if ( !onlyHandlers && !special.noBubble && !jQuery.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() ) {
+
+			event.type = i > 1 ?
+				bubbleType :
+				special.bindType || type;
+
+			// jQuery handler
+			handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] && jQuery._data( cur, "handle" );
+			if ( handle ) {
+				handle.apply( cur, data );
+			}
+
+			// Native handler
+			handle = ontype && cur[ ontype ];
+			if ( handle && jQuery.acceptData( cur ) && handle.apply && handle.apply( cur, data ) === 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( elem.ownerDocument, data ) === false) &&
+				!(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {
+
+				// Call a native DOM method on the target with the same name name as the event.
+				// Can't use an .isFunction() check here because IE6/7 fails that test.
+				// Don't do default actions on window, that's where global variables be (#6170)
+				if ( ontype && elem[ type ] && !jQuery.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;
+					try {
+						elem[ type ]();
+					} catch ( e ) {
+						// IE<9 dies on focus/blur to hidden element (#1486,#12518)
+						// only reproducible on winXP IE8 native, not IE9 in IE8 mode
+					}
+					jQuery.event.triggered = undefined;
+
+					if ( tmp ) {
+						elem[ ontype ] = tmp;
+					}
+				}
+			}
+		}
+
+		return event.result;
+	},
+
+	dispatch: function( event ) {
+
+		// Make a writable jQuery.Event from the native event object
+		event = jQuery.event.fix( event );
+
+		var i, ret, handleObj, matched, j,
+			handlerQueue = [],
+			args = core_slice.call( arguments ),
+			handlers = ( jQuery._data( this, "events" ) || {} )[ event.type ] || [],
+			special = jQuery.event.special[ event.type ] || {};
+
+		// Use the fix-ed jQuery.Event rather than the (read-only) native event
+		args[0] = event;
+		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() ) {
+
+				// Triggered event must either 1) have no namespace, or
+				// 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace).
+				if ( !event.namespace_re || event.namespace_re.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 sel, handleObj, matches, i,
+			handlerQueue = [],
+			delegateCount = handlers.delegateCount,
+			cur = event.target;
+
+		// Find delegate handlers
+		// Black-hole SVG <use> instance trees (#13180)
+		// Avoid non-left-click bubbling in Firefox (#3861)
+		if ( delegateCount && cur.nodeType && (!event.button || event.type !== "click") ) {
+
+			for ( ; cur != this; cur = cur.parentNode || this ) {
+
+				// Don't check non-elements (#13208)
+				// Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
+				if ( cur.nodeType === 1 && (cur.disabled !== true || event.type !== "click") ) {
+					matches = [];
+					for ( i = 0; i < delegateCount; i++ ) {
+						handleObj = handlers[ i ];
+
+						// Don't conflict with Object.prototype properties (#13203)
+						sel = handleObj.selector + " ";
+
+						if ( matches[ sel ] === undefined ) {
+							matches[ sel ] = handleObj.needsContext ?
+								jQuery( sel, this ).index( cur ) >= 0 :
+								jQuery.find( sel, this, null, [ cur ] ).length;
+						}
+						if ( matches[ sel ] ) {
+							matches.push( handleObj );
+						}
+					}
+					if ( matches.length ) {
+						handlerQueue.push({ elem: cur, handlers: matches });
+					}
+				}
+			}
+		}
+
+		// Add the remaining (directly-bound) handlers
+		if ( delegateCount < handlers.length ) {
+			handlerQueue.push({ elem: this, handlers: handlers.slice( delegateCount ) });
+		}
+
+		return handlerQueue;
+	},
+
+	fix: function( event ) {
+		if ( event[ jQuery.expando ] ) {
+			return event;
+		}
+
+		// Create a writable copy of the event object and normalize some properties
+		var i, prop, copy,
+			type = event.type,
+			originalEvent = event,
+			fixHook = this.fixHooks[ type ];
+
+		if ( !fixHook ) {
+			this.fixHooks[ type ] = fixHook =
+				rmouseEvent.test( type ) ? this.mouseHooks :
+				rkeyEvent.test( type ) ? this.keyHooks :
+				{};
+		}
+		copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;
+
+		event = new jQuery.Event( originalEvent );
+
+		i = copy.length;
+		while ( i-- ) {
+			prop = copy[ i ];
+			event[ prop ] = originalEvent[ prop ];
+		}
+
+		// Support: IE<9
+		// Fix target property (#1925)
+		if ( !event.target ) {
+			event.target = originalEvent.srcElement || document;
+		}
+
+		// Support: Chrome 23+, Safari?
+		// Target should not be a text node (#504, #13143)
+		if ( event.target.nodeType === 3 ) {
+			event.target = event.target.parentNode;
+		}
+
+		// Support: IE<9
+		// For mouse/key events, metaKey==false if it's undefined (#3368, #11328)
+		event.metaKey = !!event.metaKey;
+
+		return fixHook.filter ? fixHook.filter( event, originalEvent ) : event;
+	},
+
+	// Includes some event props shared by KeyEvent and MouseEvent
+	props: "altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),
+
+	fixHooks: {},
+
+	keyHooks: {
+		props: "char charCode key keyCode".split(" "),
+		filter: function( event, original ) {
+
+			// Add which for key events
+			if ( event.which == null ) {
+				event.which = original.charCode != null ? original.charCode : original.keyCode;
+			}
+
+			return event;
+		}
+	},
+
+	mouseHooks: {
+		props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),
+		filter: function( event, original ) {
+			var body, eventDoc, doc,
+				button = original.button,
+				fromElement = original.fromElement;
+
+			// Calculate pageX/Y if missing and clientX/Y available
+			if ( event.pageX == null && original.clientX != null ) {
+				eventDoc = event.target.ownerDocument || document;
+				doc = eventDoc.documentElement;
+				body = eventDoc.body;
+
+				event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 );
+				event.pageY = original.clientY + ( doc && doc.scrollTop  || body && body.scrollTop  || 0 ) - ( doc && doc.clientTop  || body && body.clientTop  || 0 );
+			}
+
+			// Add relatedTarget, if necessary
+			if ( !event.relatedTarget && fromElement ) {
+				event.relatedTarget = fromElement === event.target ? original.toElement : fromElement;
+			}
+
+			// Add which for click: 1 === left; 2 === middle; 3 === right
+			// Note: button is not normalized, so don't use it
+			if ( !event.which && button !== undefined ) {
+				event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );
+			}
+
+			return event;
+		}
+	},
+
+	special: {
+		load: {
+			// Prevent triggered image.load events from bubbling to window.load
+			noBubble: true
+		},
+		click: {
+			// For checkbox, fire native event so checked state will be right
+			trigger: function() {
+				if ( jQuery.nodeName( this, "input" ) && this.type === "checkbox" && this.click ) {
+					this.click();
+					return false;
+				}
+			}
+		},
+		focus: {
+			// Fire native event if possible so blur/focus sequence is correct
+			trigger: function() {
+				if ( this !== document.activeElement && this.focus ) {
+					try {
+						this.focus();
+						return false;
+					} catch ( e ) {
+						// Support: IE<9
+						// If we error on focus to hidden element (#1486, #12518),
+						// let .trigger() run the handlers
+					}
+				}
+			},
+			delegateType: "focusin"
+		},
+		blur: {
+			trigger: function() {
+				if ( this === document.activeElement && this.blur ) {
+					this.blur();
+					return false;
+				}
+			},
+			delegateType: "focusout"
+		},
+
+		beforeunload: {
+			postDispatch: function( event ) {
+
+				// Even when returnValue equals to undefined Firefox will still show alert
+				if ( event.result !== undefined ) {
+					event.originalEvent.returnValue = event.result;
+				}
+			}
+		}
+	},
+
+	simulate: function( type, elem, event, bubble ) {
+		// Piggyback on a donor event to simulate a different one.
+		// Fake originalEvent to avoid donor's stopPropagation, but if the
+		// simulated event prevents default then we do the same on the donor.
+		var e = jQuery.extend(
+			new jQuery.Event(),
+			event,
+			{ type: type,
+				isSimulated: true,
+				originalEvent: {}
+			}
+		);
+		if ( bubble ) {
+			jQuery.event.trigger( e, null, elem );
+		} else {
+			jQuery.event.dispatch.call( elem, e );
+		}
+		if ( e.isDefaultPrevented() ) {
+			event.preventDefault();
+		}
+	}
+};
+
+jQuery.removeEvent = document.removeEventListener ?
+	function( elem, type, handle ) {
+		if ( elem.removeEventListener ) {
+			elem.removeEventListener( type, handle, false );
+		}
+	} :
+	function( elem, type, handle ) {
+		var name = "on" + type;
+
+		if ( elem.detachEvent ) {
+
+			// #8545, #7054, preventing memory leaks for custom events in IE6-8
+			// detachEvent needed property on element, by name of that event, to properly expose it to GC
+			if ( typeof elem[ name ] === core_strundefined ) {
+				elem[ name ] = null;
+			}
+
+			elem.detachEvent( name, 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.returnValue === false ||
+			src.getPreventDefault && src.getPreventDefault() ) ? returnTrue : returnFalse;
+
+	// 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 || jQuery.now();
+
+	// Mark it as fixed
+	this[ jQuery.expando ] = true;
+};
+
+// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
+// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
+jQuery.Event.prototype = {
+	isDefaultPrevented: returnFalse,
+	isPropagationStopped: returnFalse,
+	isImmediatePropagationStopped: returnFalse,
+
+	preventDefault: function() {
+		var e = this.originalEvent;
+
+		this.isDefaultPrevented = returnTrue;
+		if ( !e ) {
+			return;
+		}
+
+		// If preventDefault exists, run it on the original event
+		if ( e.preventDefault ) {
+			e.preventDefault();
+
+		// Support: IE
+		// Otherwise set the returnValue property of the original event to false
+		} else {
+			e.returnValue = false;
+		}
+	},
+	stopPropagation: function() {
+		var e = this.originalEvent;
+
+		this.isPropagationStopped = returnTrue;
+		if ( !e ) {
+			return;
+		}
+		// If stopPropagation exists, run it on the original event
+		if ( e.stopPropagation ) {
+			e.stopPropagation();
+		}
+
+		// Support: IE
+		// Set the cancelBubble property of the original event to true
+		e.cancelBubble = true;
+	},
+	stopImmediatePropagation: function() {
+		this.isImmediatePropagationStopped = returnTrue;
+		this.stopPropagation();
+	}
+};
+
+// Create mouseenter/leave events using mouseover/out and event-time checks
+jQuery.each({
+	mouseenter: "mouseover",
+	mouseleave: "mouseout"
+}, 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 mousenter/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;
+		}
+	};
+});
+
+// IE submit delegation
+if ( !jQuery.support.submitBubbles ) {
+
+	jQuery.event.special.submit = {
+		setup: function() {
+			// Only need this for delegated form submit events
+			if ( jQuery.nodeName( this, "form" ) ) {
+				return false;
+			}
+
+			// Lazy-add a submit handler when a descendant form may potentially be submitted
+			jQuery.event.add( this, "click._submit keypress._submit", function( e ) {
+				// Node name check avoids a VML-related crash in IE (#9807)
+				var elem = e.target,
+					form = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.form : undefined;
+				if ( form && !jQuery._data( form, "submitBubbles" ) ) {
+					jQuery.event.add( form, "submit._submit", function( event ) {
+						event._submit_bubble = true;
+					});
+					jQuery._data( form, "submitBubbles", true );
+				}
+			});
+			// return undefined since we don't need an event listener
+		},
+
+		postDispatch: function( event ) {
+			// If form was submitted by the user, bubble the event up the tree
+			if ( event._submit_bubble ) {
+				delete event._submit_bubble;
+				if ( this.parentNode && !event.isTrigger ) {
+					jQuery.event.simulate( "submit", this.parentNode, event, true );
+				}
+			}
+		},
+
+		teardown: function() {
+			// Only need this for delegated form submit events
+			if ( jQuery.nodeName( this, "form" ) ) {
+				return false;
+			}
+
+			// Remove delegated handlers; cleanData eventually reaps submit handlers attached above
+			jQuery.event.remove( this, "._submit" );
+		}
+	};
+}
+
+// IE change delegation and checkbox/radio fix
+if ( !jQuery.support.changeBubbles ) {
+
+	jQuery.event.special.change = {
+
+		setup: function() {
+
+			if ( rformElems.test( this.nodeName ) ) {
+				// IE doesn't fire change on a check/radio until blur; trigger it on click
+				// after a propertychange. Eat the blur-change in special.change.handle.
+				// This still fires onchange a second time for check/radio after blur.
+				if ( this.type === "checkbox" || this.type === "radio" ) {
+					jQuery.event.add( this, "propertychange._change", function( event ) {
+						if ( event.originalEvent.propertyName === "checked" ) {
+							this._just_changed = true;
+						}
+					});
+					jQuery.event.add( this, "click._change", function( event ) {
+						if ( this._just_changed && !event.isTrigger ) {
+							this._just_changed = false;
+						}
+						// Allow triggered, simulated change events (#11500)
+						jQuery.event.simulate( "change", this, event, true );
+					});
+				}
+				return false;
+			}
+			// Delegated event; lazy-add a change handler on descendant inputs
+			jQuery.event.add( this, "beforeactivate._change", function( e ) {
+				var elem = e.target;
+
+				if ( rformElems.test( elem.nodeName ) && !jQuery._data( elem, "changeBubbles" ) ) {
+					jQuery.event.add( elem, "change._change", function( event ) {
+						if ( this.parentNode && !event.isSimulated && !event.isTrigger ) {
+							jQuery.event.simulate( "change", this.parentNode, event, true );
+						}
+					});
+					jQuery._data( elem, "changeBubbles", true );
+				}
+			});
+		},
+
+		handle: function( event ) {
+			var elem = event.target;
+
+			// Swallow native change events from checkbox/radio, we already triggered them above
+			if ( this !== elem || event.isSimulated || event.isTrigger || (elem.type !== "radio" && elem.type !== "checkbox") ) {
+				return event.handleObj.handler.apply( this, arguments );
+			}
+		},
+
+		teardown: function() {
+			jQuery.event.remove( this, "._change" );
+
+			return !rformElems.test( this.nodeName );
+		}
+	};
+}
+
+// Create "bubbling" focus and blur events
+if ( !jQuery.support.focusinBubbles ) {
+	jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
+
+		// Attach a single capturing handler while someone wants focusin/focusout
+		var attaches = 0,
+			handler = function( event ) {
+				jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ), true );
+			};
+
+		jQuery.event.special[ fix ] = {
+			setup: function() {
+				if ( attaches++ === 0 ) {
+					document.addEventListener( orig, handler, true );
+				}
+			},
+			teardown: function() {
+				if ( --attaches === 0 ) {
+					document.removeEventListener( orig, handler, true );
+				}
+			}
+		};
+	});
+}
+
+jQuery.fn.extend({
+
+	on: function( types, selector, data, fn, /*INTERNAL*/ one ) {
+		var type, origFn;
+
+		// 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 ) {
+				this.on( type, selector, data, types[ type ], one );
+			}
+			return this;
+		}
+
+		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 this;
+		}
+
+		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 this.each( function() {
+			jQuery.event.add( this, types, fn, data, selector );
+		});
+	},
+	one: function( types, selector, data, fn ) {
+		return this.on( 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 );
+		});
+	},
+
+	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 );
+	},
+
+	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 );
+		}
+	}
+});
+/*!
+ * Sizzle CSS Selector Engine
+ * Copyright 2012 jQuery Foundation and other contributors
+ * Released under the MIT license
+ * http://sizzlejs.com/
+ */
+(function( window, undefined ) {
+
+var i,
+	cachedruns,
+	Expr,
+	getText,
+	isXML,
+	compile,
+	hasDuplicate,
+	outermostContext,
+
+	// Local document vars
+	setDocument,
+	document,
+	docElem,
+	documentIsXML,
+	rbuggyQSA,
+	rbuggyMatches,
+	matches,
+	contains,
+	sortOrder,
+
+	// Instance-specific data
+	expando = "sizzle" + -(new Date()),
+	preferredDoc = window.document,
+	support = {},
+	dirruns = 0,
+	done = 0,
+	classCache = createCache(),
+	tokenCache = createCache(),
+	compilerCache = createCache(),
+
+	// General-purpose constants
+	strundefined = typeof undefined,
+	MAX_NEGATIVE = 1 << 31,
+
+	// Array methods
+	arr = [],
+	pop = arr.pop,
+	push = arr.push,
+	slice = arr.slice,
+	// Use a stripped-down indexOf if we can't use a native one
+	indexOf = arr.indexOf || function( elem ) {
+		var i = 0,
+			len = this.length;
+		for ( ; i < len; i++ ) {
+			if ( this[i] === elem ) {
+				return i;
+			}
+		}
+		return -1;
+	},
+
+
+	// Regular expressions
+
+	// Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace
+	whitespace = "[\\x20\\t\\r\\n\\f]",
+	// http://www.w3.org/TR/css3-syntax/#characters
+	characterEncoding = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",
+
+	// Loosely modeled on CSS identifier characters
+	// An unquoted value should be a CSS identifier http://www.w3.org/TR/css3-selectors/#attribute-selectors
+	// Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
+	identifier = characterEncoding.replace( "w", "w#" ),
+
+	// Acceptable operators http://www.w3.org/TR/selectors/#attribute-selectors
+	operators = "([*^$|!~]?=)",
+	attributes = "\\[" + whitespace + "*(" + characterEncoding + ")" + whitespace +
+		"*(?:" + operators + whitespace + "*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|(" + identifier + ")|)|)" + whitespace + "*\\]",
+
+	// Prefer arguments quoted,
+	//   then not containing pseudos/brackets,
+	//   then attribute selectors/non-parenthetical expressions,
+	//   then anything else
+	// These preferences are here to reduce the number of selectors
+	//   needing tokenize in the PSEUDO preFilter
+	pseudos = ":(" + characterEncoding + ")(?:\\(((['\"])((?:\\\\.|[^\\\\])*?)\\3|((?:\\\\.|[^\\\\()[\\]]|" + attributes.replace( 3, 8 ) + ")*)|.*)\\)|)",
+
+	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
+	rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
+
+	rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
+	rcombinators = new RegExp( "^" + whitespace + "*([\\x20\\t\\r\\n\\f>+~])" + whitespace + "*" ),
+	rpseudo = new RegExp( pseudos ),
+	ridentifier = new RegExp( "^" + identifier + "$" ),
+
+	matchExpr = {
+		"ID": new RegExp( "^#(" + characterEncoding + ")" ),
+		"CLASS": new RegExp( "^\\.(" + characterEncoding + ")" ),
+		"NAME": new RegExp( "^\\[name=['\"]?(" + characterEncoding + ")['\"]?\\]" ),
+		"TAG": new RegExp( "^(" + characterEncoding.replace( "w", "w*" ) + ")" ),
+		"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" ),
+		// 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" )
+	},
+
+	rsibling = /[\x20\t\r\n\f]*[+~]/,
+
+	rnative = /^[^{]+\{\s*\[native code/,
+
+	// Easily-parseable/retrievable ID or TAG or CLASS selectors
+	rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
+
+	rinputs = /^(?:input|select|textarea|button)$/i,
+	rheader = /^h\d$/i,
+
+	rescape = /'|\\/g,
+	rattributeQuotes = /\=[\x20\t\r\n\f]*([^'"\]]*)[\x20\t\r\n\f]*\]/g,
+
+	// CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
+	runescape = /\\([\da-fA-F]{1,6}[\x20\t\r\n\f]?|.)/g,
+	funescape = function( _, escaped ) {
+		var high = "0x" + escaped - 0x10000;
+		// NaN means non-codepoint
+		return high !== high ?
+			escaped :
+			// BMP codepoint
+			high < 0 ?
+				String.fromCharCode( high + 0x10000 ) :
+				// Supplemental Plane codepoint (surrogate pair)
+				String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
+	};
+
+// Use a stripped-down slice if we can't use a native one
+try {
+	slice.call( preferredDoc.documentElement.childNodes, 0 )[0].nodeType;
+} catch ( e ) {
+	slice = function( i ) {
+		var elem,
+			results = [];
+		while ( (elem = this[i++]) ) {
+			results.push( elem );
+		}
+		return results;
+	};
+}
+
+/**
+ * For feature detection
+ * @param {Function} fn The function to test for native support
+ */
+function isNative( fn ) {
+	return rnative.test( fn + "" );
+}
+
+/**
+ * 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 cache,
+		keys = [];
+
+	return (cache = function( key, value ) {
+		// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
+		if ( keys.push( key += " " ) > Expr.cacheLength ) {
+			// Only keep the most recent entries
+			delete cache[ keys.shift() ];
+		}
+		return (cache[ key ] = value);
+	});
+}
+
+/**
+ * Mark a function for special use by Sizzle
+ * @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 div and expects a boolean result
+ */
+function assert( fn ) {
+	var div = document.createElement("div");
+
+	try {
+		return fn( div );
+	} catch (e) {
+		return false;
+	} finally {
+		// release memory in IE
+		div = null;
+	}
+}
+
+function Sizzle( selector, context, results, seed ) {
+	var match, elem, m, nodeType,
+		// QSA vars
+		i, groups, old, nid, newContext, newSelector;
+
+	if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
+		setDocument( context );
+	}
+
+	context = context || document;
+	results = results || [];
+
+	if ( !selector || typeof selector !== "string" ) {
+		return results;
+	}
+
+	if ( (nodeType = context.nodeType) !== 1 && nodeType !== 9 ) {
+		return [];
+	}
+
+	if ( !documentIsXML && !seed ) {
+
+		// Shortcuts
+		if ( (match = rquickExpr.exec( selector )) ) {
+			// Speed-up: Sizzle("#ID")
+			if ( (m = match[1]) ) {
+				if ( nodeType === 9 ) {
+					elem = context.getElementById( m );
+					// Check parentNode to catch when Blackberry 4.6 returns
+					// nodes that are no longer in the document #6963
+					if ( elem && elem.parentNode ) {
+						// Handle the case where IE, Opera, and Webkit return items
+						// by name instead of ID
+						if ( elem.id === m ) {
+							results.push( elem );
+							return results;
+						}
+					} else {
+						return results;
+					}
+				} else {
+					// Context is not a document
+					if ( context.ownerDocument && (elem = context.ownerDocument.getElementById( m )) &&
+						contains( context, elem ) && elem.id === m ) {
+						results.push( elem );
+						return results;
+					}
+				}
+
+			// Speed-up: Sizzle("TAG")
+			} else if ( match[2] ) {
+				push.apply( results, slice.call(context.getElementsByTagName( selector ), 0) );
+				return results;
+
+			// Speed-up: Sizzle(".CLASS")
+			} else if ( (m = match[3]) && support.getByClassName && context.getElementsByClassName ) {
+				push.apply( results, slice.call(context.getElementsByClassName( m ), 0) );
+				return results;
+			}
+		}
+
+		// QSA path
+		if ( support.qsa && !rbuggyQSA.test(selector) ) {
+			old = true;
+			nid = expando;
+			newContext = context;
+			newSelector = nodeType === 9 && selector;
+
+			// qSA works strangely on Element-rooted queries
+			// We can work around this by specifying an extra ID on the root
+			// and working up from there (Thanks to Andrew Dupont for the technique)
+			// IE 8 doesn't work on object elements
+			if ( nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
+				groups = tokenize( selector );
+
+				if ( (old = context.getAttribute("id")) ) {
+					nid = old.replace( rescape, "\\$&" );
+				} else {
+					context.setAttribute( "id", nid );
+				}
+				nid = "[id='" + nid + "'] ";
+
+				i = groups.length;
+				while ( i-- ) {
+					groups[i] = nid + toSelector( groups[i] );
+				}
+				newContext = rsibling.test( selector ) && context.parentNode || context;
+				newSelector = groups.join(",");
+			}
+
+			if ( newSelector ) {
+				try {
+					push.apply( results, slice.call( newContext.querySelectorAll(
+						newSelector
+					), 0 ) );
+					return results;
+				} catch(qsaError) {
+				} finally {
+					if ( !old ) {
+						context.removeAttribute("id");
+					}
+				}
+			}
+		}
+	}
+
+	// All others
+	return select( selector.replace( rtrim, "$1" ), context, results, seed );
+}
+
+/**
+ * Detect xml
+ * @param {Element|Object} elem An element or a document
+ */
+isXML = Sizzle.isXML = function( elem ) {
+	// documentElement is verified for cases where it doesn't yet exist
+	// (such as loading iframes in IE - #4833)
+	var documentElement = elem && (elem.ownerDocument || elem).documentElement;
+	return documentElement ? documentElement.nodeName !== "HTML" : false;
+};
+
+/**
+ * Sets document-related variables once based on the current document
+ * @param {Element|Object} [doc] An element or document object to use to set the document
+ * @returns {Object} Returns the current document
+ */
+setDocument = Sizzle.setDocument = function( node ) {
+	var doc = node ? node.ownerDocument || node : preferredDoc;
+
+	// If no document and documentElement is available, return
+	if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
+		return document;
+	}
+
+	// Set our document
+	document = doc;
+	docElem = doc.documentElement;
+
+	// Support tests
+	documentIsXML = isXML( doc );
+
+	// Check if getElementsByTagName("*") returns only elements
+	support.tagNameNoComments = assert(function( div ) {
+		div.appendChild( doc.createComment("") );
+		return !div.getElementsByTagName("*").length;
+	});
+
+	// Check if attributes should be retrieved by attribute nodes
+	support.attributes = assert(function( div ) {
+		div.innerHTML = "<select></select>";
+		var type = typeof div.lastChild.getAttribute("multiple");
+		// IE8 returns a string for some attributes even when not present
+		return type !== "boolean" && type !== "string";
+	});
+
+	// Check if getElementsByClassName can be trusted
+	support.getByClassName = assert(function( div ) {
+		// Opera can't find a second classname (in 9.6)
+		div.innerHTML = "<div class='hidden e'></div><div class='hidden'></div>";
+		if ( !div.getElementsByClassName || !div.getElementsByClassName("e").length ) {
+			return false;
+		}
+
+		// Safari 3.2 caches class attributes and doesn't catch changes
+		div.lastChild.className = "e";
+		return div.getElementsByClassName("e").length === 2;
+	});
+
+	// Check if getElementById returns elements by name
+	// Check if getElementsByName privileges form controls or returns elements by ID
+	support.getByName = assert(function( div ) {
+		// Inject content
+		div.id = expando + 0;
+		div.innerHTML = "<a name='" + expando + "'></a><div name='" + expando + "'></div>";
+		docElem.insertBefore( div, docElem.firstChild );
+
+		// Test
+		var pass = doc.getElementsByName &&
+			// buggy browsers will return fewer than the correct 2
+			doc.getElementsByName( expando ).length === 2 +
+			// buggy browsers will return more than the correct 0
+			doc.getElementsByName( expando + 0 ).length;
+		support.getIdNotName = !doc.getElementById( expando );
+
+		// Cleanup
+		docElem.removeChild( div );
+
+		return pass;
+	});
+
+	// IE6/7 return modified attributes
+	Expr.attrHandle = assert(function( div ) {
+		div.innerHTML = "<a href='#'></a>";
+		return div.firstChild && typeof div.firstChild.getAttribute !== strundefined &&
+			div.firstChild.getAttribute("href") === "#";
+	}) ?
+		{} :
+		{
+			"href": function( elem ) {
+				return elem.getAttribute( "href", 2 );
+			},
+			"type": function( elem ) {
+				return elem.getAttribute("type");
+			}
+		};
+
+	// ID find and filter
+	if ( support.getIdNotName ) {
+		Expr.find["ID"] = function( id, context ) {
+			if ( typeof context.getElementById !== strundefined && !documentIsXML ) {
+				var m = context.getElementById( id );
+				// Check parentNode to catch when Blackberry 4.6 returns
+				// nodes that are no longer in the document #6963
+				return m && m.parentNode ? [m] : [];
+			}
+		};
+		Expr.filter["ID"] = function( id ) {
+			var attrId = id.replace( runescape, funescape );
+			return function( elem ) {
+				return elem.getAttribute("id") === attrId;
+			};
+		};
+	} else {
+		Expr.find["ID"] = function( id, context ) {
+			if ( typeof context.getElementById !== strundefined && !documentIsXML ) {
+				var m = context.getElementById( id );
+
+				return m ?
+					m.id === id || typeof m.getAttributeNode !== strundefined && m.getAttributeNode("id").value === id ?
+						[m] :
+						undefined :
+					[];
+			}
+		};
+		Expr.filter["ID"] =  function( id ) {
+			var attrId = id.replace( runescape, funescape );
+			return function( elem ) {
+				var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode("id");
+				return node && node.value === attrId;
+			};
+		};
+	}
+
+	// Tag
+	Expr.find["TAG"] = support.tagNameNoComments ?
+		function( tag, context ) {
+			if ( typeof context.getElementsByTagName !== strundefined ) {
+				return context.getElementsByTagName( tag );
+			}
+		} :
+		function( tag, context ) {
+			var elem,
+				tmp = [],
+				i = 0,
+				results = context.getElementsByTagName( tag );
+
+			// Filter out possible comments
+			if ( tag === "*" ) {
+				while ( (elem = results[i++]) ) {
+					if ( elem.nodeType === 1 ) {
+						tmp.push( elem );
+					}
+				}
+
+				return tmp;
+			}
+			return results;
+		};
+
+	// Name
+	Expr.find["NAME"] = support.getByName && function( tag, context ) {
+		if ( typeof context.getElementsByName !== strundefined ) {
+			return context.getElementsByName( name );
+		}
+	};
+
+	// Class
+	Expr.find["CLASS"] = support.getByClassName && function( className, context ) {
+		if ( typeof context.getElementsByClassName !== strundefined && !documentIsXML ) {
+			return context.getElementsByClassName( className );
+		}
+	};
+
+	// QSA and matchesSelector support
+
+	// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
+	rbuggyMatches = [];
+
+	// qSa(:focus) reports false when true (Chrome 21),
+	// no need to also add to buggyMatches since matches checks buggyQSA
+	// A support test would require too much code (would include document ready)
+	rbuggyQSA = [ ":focus" ];
+
+	if ( (support.qsa = isNative(doc.querySelectorAll)) ) {
+		// Build QSA regex
+		// Regex strategy adopted from Diego Perini
+		assert(function( div ) {
+			// Select is set to empty string on purpose
+			// This is to test IE's treatment of not explictly
+			// setting a boolean content attribute,
+			// since its presence should be enough
+			// http://bugs.jquery.com/ticket/12359
+			div.innerHTML = "<select><option selected=''></option></select>";
+
+			// IE8 - Some boolean attributes are not treated correctly
+			if ( !div.querySelectorAll("[selected]").length ) {
+				rbuggyQSA.push( "\\[" + whitespace + "*(?:checked|disabled|ismap|multiple|readonly|selected|value)" );
+			}
+
+			// Webkit/Opera - :checked should return selected option elements
+			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
+			// IE8 throws error here and will not see later tests
+			if ( !div.querySelectorAll(":checked").length ) {
+				rbuggyQSA.push(":checked");
+			}
+		});
+
+		assert(function( div ) {
+
+			// Opera 10-12/IE8 - ^= $= *= and empty values
+			// Should not select anything
+			div.innerHTML = "<input type='hidden' i=''/>";
+			if ( div.querySelectorAll("[i^='']").length ) {
+				rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:\"\"|'')" );
+			}
+
+			// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
+			// IE8 throws error here and will not see later tests
+			if ( !div.querySelectorAll(":enabled").length ) {
+				rbuggyQSA.push( ":enabled", ":disabled" );
+			}
+
+			// Opera 10-11 does not throw on post-comma invalid pseudos
+			div.querySelectorAll("*,:x");
+			rbuggyQSA.push(",.*:");
+		});
+	}
+
+	if ( (support.matchesSelector = isNative( (matches = docElem.matchesSelector ||
+		docElem.mozMatchesSelector ||
+		docElem.webkitMatchesSelector ||
+		docElem.oMatchesSelector ||
+		docElem.msMatchesSelector) )) ) {
+
+		assert(function( div ) {
+			// Check to see if it's possible to do matchesSelector
+			// on a disconnected node (IE 9)
+			support.disconnectedMatch = matches.call( div, "div" );
+
+			// This should fail with an exception
+			// Gecko does not error, returns false instead
+			matches.call( div, "[s!='']:x" );
+			rbuggyMatches.push( "!=", pseudos );
+		});
+	}
+
+	rbuggyQSA = new RegExp( rbuggyQSA.join("|") );
+	rbuggyMatches = new RegExp( rbuggyMatches.join("|") );
+
+	// Element contains another
+	// Purposefully does not implement inclusive descendent
+	// As in, an element does not contain itself
+	contains = isNative(docElem.contains) || docElem.compareDocumentPosition ?
+		function( a, b ) {
+			var adown = a.nodeType === 9 ? a.documentElement : a,
+				bup = b && b.parentNode;
+			return a === bup || !!( bup && bup.nodeType === 1 && (
+				adown.contains ?
+					adown.contains( bup ) :
+					a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
+			));
+		} :
+		function( a, b ) {
+			if ( b ) {
+				while ( (b = b.parentNode) ) {
+					if ( b === a ) {
+						return true;
+					}
+				}
+			}
+			return false;
+		};
+
+	// Document order sorting
+	sortOrder = docElem.compareDocumentPosition ?
+	function( a, b ) {
+		var compare;
+
+		if ( a === b ) {
+			hasDuplicate = true;
+			return 0;
+		}
+
+		if ( (compare = b.compareDocumentPosition && a.compareDocumentPosition && a.compareDocumentPosition( b )) ) {
+			if ( compare & 1 || a.parentNode && a.parentNode.nodeType === 11 ) {
+				if ( a === doc || contains( preferredDoc, a ) ) {
+					return -1;
+				}
+				if ( b === doc || contains( preferredDoc, b ) ) {
+					return 1;
+				}
+				return 0;
+			}
+			return compare & 4 ? -1 : 1;
+		}
+
+		return a.compareDocumentPosition ? -1 : 1;
+	} :
+	function( a, b ) {
+		var cur,
+			i = 0,
+			aup = a.parentNode,
+			bup = b.parentNode,
+			ap = [ a ],
+			bp = [ b ];
+
+		// Exit early if the nodes are identical
+		if ( a === b ) {
+			hasDuplicate = true;
+			return 0;
+
+		// Parentless nodes are either documents or disconnected
+		} else if ( !aup || !bup ) {
+			return a === doc ? -1 :
+				b === doc ? 1 :
+				aup ? -1 :
+				bup ? 1 :
+				0;
+
+		// If the nodes are siblings, we can do a quick check
+		} else if ( aup === bup ) {
+			return siblingCheck( a, b );
+		}
+
+		// Otherwise we need full lists of their ancestors for comparison
+		cur = a;
+		while ( (cur = cur.parentNode) ) {
+			ap.unshift( cur );
+		}
+		cur = b;
+		while ( (cur = cur.parentNode) ) {
+			bp.unshift( cur );
+		}
+
+		// Walk down the tree looking for a discrepancy
+		while ( ap[i] === bp[i] ) {
+			i++;
+		}
+
+		return i ?
+			// Do a sibling check if the nodes have a common ancestor
+			siblingCheck( ap[i], bp[i] ) :
+
+			// Otherwise nodes in our document sort first
+			ap[i] === preferredDoc ? -1 :
+			bp[i] === preferredDoc ? 1 :
+			0;
+	};
+
+	// Always assume the presence of duplicates if sort doesn't
+	// pass them to our comparison function (as in Google Chrome).
+	hasDuplicate = false;
+	[0, 0].sort( sortOrder );
+	support.detectDuplicates = hasDuplicate;
+
+	return document;
+};
+
+Sizzle.matches = function( expr, elements ) {
+	return Sizzle( expr, null, null, elements );
+};
+
+Sizzle.matchesSelector = function( elem, expr ) {
+	// Set document vars if needed
+	if ( ( elem.ownerDocument || elem ) !== document ) {
+		setDocument( elem );
+	}
+
+	// Make sure that attribute selectors are quoted
+	expr = expr.replace( rattributeQuotes, "='$1']" );
+
+	// rbuggyQSA always contains :focus, so no need for an existence check
+	if ( support.matchesSelector && !documentIsXML && (!rbuggyMatches || !rbuggyMatches.test(expr)) && !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) {}
+	}
+
+	return Sizzle( expr, document, null, [elem] ).length > 0;
+};
+
+Sizzle.contains = function( context, elem ) {
+	// Set document vars if needed
+	if ( ( context.ownerDocument || context ) !== document ) {
+		setDocument( context );
+	}
+	return contains( context, elem );
+};
+
+Sizzle.attr = function( elem, name ) {
+	var val;
+
+	// Set document vars if needed
+	if ( ( elem.ownerDocument || elem ) !== document ) {
+		setDocument( elem );
+	}
+
+	if ( !documentIsXML ) {
+		name = name.toLowerCase();
+	}
+	if ( (val = Expr.attrHandle[ name ]) ) {
+		return val( elem );
+	}
+	if ( documentIsXML || support.attributes ) {
+		return elem.getAttribute( name );
+	}
+	return ( (val = elem.getAttributeNode( name )) || elem.getAttribute( name ) ) && elem[ name ] === true ?
+		name :
+		val && val.specified ? val.value : null;
+};
+
+Sizzle.error = function( msg ) {
+	throw new Error( "Syntax error, unrecognized expression: " + msg );
+};
+
+// Document sorting and removing duplicates
+Sizzle.uniqueSort = function( results ) {
+	var elem,
+		duplicates = [],
+		i = 1,
+		j = 0;
+
+	// Unless we *know* we can detect duplicates, assume their presence
+	hasDuplicate = !support.detectDuplicates;
+	results.sort( sortOrder );
+
+	if ( hasDuplicate ) {
+		for ( ; (elem = results[i]); i++ ) {
+			if ( elem === results[ i - 1 ] ) {
+				j = duplicates.push( i );
+			}
+		}
+		while ( j-- ) {
+			results.splice( duplicates[ j ], 1 );
+		}
+	}
+
+	return results;
+};
+
+function siblingCheck( a, b ) {
+	var cur = b && a,
+		diff = cur && ( ~b.sourceIndex || MAX_NEGATIVE ) - ( ~a.sourceIndex || MAX_NEGATIVE );
+
+	// Use IE sourceIndex if available on both nodes
+	if ( diff ) {
+		return diff;
+	}
+
+	// Check if b follows a
+	if ( cur ) {
+		while ( (cur = cur.nextSibling) ) {
+			if ( cur === b ) {
+				return -1;
+			}
+		}
+	}
+
+	return a ? 1 : -1;
+}
+
+// Returns a function to use in pseudos for input types
+function createInputPseudo( type ) {
+	return function( elem ) {
+		var name = elem.nodeName.toLowerCase();
+		return name === "input" && elem.type === type;
+	};
+}
+
+// Returns a function to use in pseudos for buttons
+function createButtonPseudo( type ) {
+	return function( elem ) {
+		var name = elem.nodeName.toLowerCase();
+		return (name === "input" || name === "button") && elem.type === type;
+	};
+}
+
+// Returns a function to use in pseudos for positionals
+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]);
+				}
+			}
+		});
+	});
+}
+
+/**
+ * Utility function for retrieving the text value of an array of DOM nodes
+ * @param {Array|Element} elem
+ */
+getText = Sizzle.getText = function( elem ) {
+	var node,
+		ret = "",
+		i = 0,
+		nodeType = elem.nodeType;
+
+	if ( !nodeType ) {
+		// If no nodeType, this is expected to be an array
+		for ( ; (node = elem[i]); i++ ) {
+			// Do not traverse comment nodes
+			ret += getText( node );
+		}
+	} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
+		// Use textContent for elements
+		// innerText usage removed for consistency of new lines (see #11153)
+		if ( typeof elem.textContent === "string" ) {
+			return elem.textContent;
+		} else {
+			// Traverse its children
+			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
+				ret += getText( elem );
+			}
+		}
+	} else if ( nodeType === 3 || nodeType === 4 ) {
+		return elem.nodeValue;
+	}
+	// Do not include comment or processing instruction nodes
+
+	return ret;
+};
+
+Expr = Sizzle.selectors = {
+
+	// Can be adjusted by the user
+	cacheLength: 50,
+
+	createPseudo: markFunction,
+
+	match: matchExpr,
+
+	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[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] ) {
+					Sizzle.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] ) {
+				Sizzle.error( match[0] );
+			}
+
+			return match;
+		},
+
+		"PSEUDO": function( match ) {
+			var excess,
+				unquoted = !match[5] && match[2];
+
+			if ( matchExpr["CHILD"].test( match[0] ) ) {
+				return null;
+			}
+
+			// Accept quoted arguments as-is
+			if ( match[4] ) {
+				match[2] = match[4];
+
+			// 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( nodeName ) {
+			if ( nodeName === "*" ) {
+				return function() { return true; };
+			}
+
+			nodeName = nodeName.replace( runescape, funescape ).toLowerCase();
+			return function( elem ) {
+				return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
+			};
+		},
+
+		"CLASS": function( className ) {
+			var pattern = classCache[ className + " " ];
+
+			return pattern ||
+				(pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
+				classCache( className, function( elem ) {
+					return pattern.test( elem.className || (typeof elem.getAttribute !== strundefined && elem.getAttribute("class")) || "" );
+				});
+		},
+
+		"ATTR": function( name, operator, check ) {
+			return function( elem ) {
+				var result = Sizzle.attr( elem, name );
+
+				if ( result == null ) {
+					return operator === "!=";
+				}
+				if ( !operator ) {
+					return true;
+				}
+
+				result += "";
+
+				return operator === "=" ? result === check :
+					operator === "!=" ? result !== check :
+					operator === "^=" ? check && result.indexOf( check ) === 0 :
+					operator === "*=" ? check && result.indexOf( check ) > -1 :
+					operator === "$=" ? check && result.slice( -check.length ) === check :
+					operator === "~=" ? ( " " + result + " " ).indexOf( check ) > -1 :
+					operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
+					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, diff, nodeIndex, start,
+						dir = simple !== forward ? "nextSibling" : "previousSibling",
+						parent = elem.parentNode,
+						name = ofType && elem.nodeName.toLowerCase(),
+						useCache = !xml && !ofType;
+
+					if ( parent ) {
+
+						// :(first|last|only)-(child|of-type)
+						if ( simple ) {
+							while ( dir ) {
+								node = elem;
+								while ( (node = node[ dir ]) ) {
+									if ( ofType ? node.nodeName.toLowerCase() === 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 = cache[0] === dirruns && 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;
+								}
+							}
+
+						// Use previously-cached element index if available
+						} else if ( useCache && (cache = (elem[ expando ] || (elem[ expando ] = {}))[ type ]) && cache[0] === dirruns ) {
+							diff = cache[1];
+
+						// xml :nth-child(...) or :nth-last-child(...) or :nth(-last)?-of-type(...)
+						} else {
+							// 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 ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) && ++diff ) {
+									// Cache the index of each encountered element
+									if ( useCache ) {
+										(node[ expando ] || (node[ expando ] = {}))[ 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
+			// http://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() ] ||
+					Sizzle.error( "unsupported pseudo: " + pseudo );
+
+			// The user may use createPseudo to indicate that
+			// arguments are needed to create the filter function
+			// just as Sizzle 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( rtrim, "$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 );
+					return !results.pop();
+				};
+		}),
+
+		"has": markFunction(function( selector ) {
+			return function( elem ) {
+				return Sizzle( selector, elem ).length > 0;
+			};
+		}),
+
+		"contains": markFunction(function( text ) {
+			return function( elem ) {
+				return ( elem.textContent || elem.innerText || getText( 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."
+		// http://www.w3.org/TR/selectors/#lang-pseudo
+		"lang": markFunction( function( lang ) {
+			// lang value must be a valid identifider
+			if ( !ridentifier.test(lang || "") ) {
+				Sizzle.error( "unsupported lang: " + lang );
+			}
+			lang = lang.replace( runescape, funescape ).toLowerCase();
+			return function( elem ) {
+				var elemLang;
+				do {
+					if ( (elemLang = documentIsXML ?
+						elem.getAttribute("xml:lang") || elem.getAttribute("lang") :
+						elem.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 === docElem;
+		},
+
+		"focus": function( elem ) {
+			return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
+		},
+
+		// Boolean properties
+		"enabled": function( elem ) {
+			return elem.disabled === false;
+		},
+
+		"disabled": function( elem ) {
+			return elem.disabled === true;
+		},
+
+		"checked": function( elem ) {
+			// In CSS3, :checked should return both checked and selected elements
+			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
+			var nodeName = elem.nodeName.toLowerCase();
+			return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
+		},
+
+		"selected": function( elem ) {
+			// Accessing this property makes selected-by-default
+			// options in Safari work properly
+			if ( elem.parentNode ) {
+				elem.parentNode.selectedIndex;
+			}
+
+			return elem.selected === true;
+		},
+
+		// Contents
+		"empty": function( elem ) {
+			// http://www.w3.org/TR/selectors/#empty-pseudo
+			// :empty is only affected by element nodes and content nodes(including text(3), cdata(4)),
+			//   not comment, processing instructions, or others
+			// Thanks to Diego Perini for the nodeName shortcut
+			//   Greater than "@" means alpha characters (specifically not starting with "#" or "?")
+			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
+				if ( elem.nodeName > "@" || elem.nodeType === 3 || elem.nodeType === 4 ) {
+					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 ) {
+			var name = elem.nodeName.toLowerCase();
+			return name === "input" && elem.type === "button" || name === "button";
+		},
+
+		"text": function( elem ) {
+			var attr;
+			// IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc)
+			// use getAttribute instead to test this case
+			return elem.nodeName.toLowerCase() === "input" &&
+				elem.type === "text" &&
+				( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === elem.type );
+		},
+
+		// 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 = argument < 0 ? argument + length : 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;
+		})
+	}
+};
+
+// 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 );
+}
+
+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 = rcombinators.exec( soFar )) ) {
+			matched = match.shift();
+			tokens.push( {
+				value: matched,
+				// Cast descendant combinators to space
+				type: match[0].replace( rtrim, " " )
+			} );
+			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
+	return parseOnly ?
+		soFar.length :
+		soFar ?
+			Sizzle.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,
+		checkNonElements = base && dir === "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 );
+				}
+			}
+		} :
+
+		// Check against all ancestor/preceding elements
+		function( elem, context, xml ) {
+			var data, cache, outerCache,
+				dirkey = dirruns + " " + doneName;
+
+			// We can't set arbitrary data on XML nodes, so they don't benefit from dir 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 ( (cache = outerCache[ dir ]) && cache[0] === dirkey ) {
+							if ( (data = cache[1]) === true || data === cachedruns ) {
+								return data === true;
+							}
+						} else {
+							cache = outerCache[ dir ] = [ dirkey ];
+							cache[1] = matcher( elem, context, xml ) || cachedruns;
+							if ( cache[1] === true ) {
+								return true;
+							}
+						}
+					}
+				}
+			}
+		};
+}
+
+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 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,
+			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,
+
+			matcherOut = matcher ?
+				// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
+				postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
+
+					// ...intermediate processing is necessary
+					[] :
+
+					// ...otherwise use results directly
+					results :
+				matcherIn;
+
+		// Find primary matches
+		if ( matcher ) {
+			matcher( matcherIn, matcherOut, context, xml );
+		}
+
+		// 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 ) {
+			return ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
+				(checkContext = context).nodeType ?
+					matchContext( elem, context, xml ) :
+					matchAnyContext( elem, context, xml ) );
+		} ];
+
+	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( tokens.slice( 0, i - 1 ) ).replace( rtrim, "$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 ) {
+	// A counter to specify which element is currently being matched
+	var matcherCachedRuns = 0,
+		bySet = setMatchers.length > 0,
+		byElement = elementMatchers.length > 0,
+		superMatcher = function( seed, context, xml, results, expandContext ) {
+			var elem, j, matcher,
+				setMatched = [],
+				matchedCount = 0,
+				i = "0",
+				unmatched = seed && [],
+				outermost = expandContext != null,
+				contextBackup = outermostContext,
+				// We must always have either seed elements or context
+				elems = seed || byElement && Expr.find["TAG"]( "*", expandContext && context.parentNode || context ),
+				// Use integer dirruns iff this is the outermost matcher
+				dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1);
+
+			if ( outermost ) {
+				outermostContext = context !== document && context;
+				cachedruns = matcherCachedRuns;
+			}
+
+			// Add elements passing elementMatchers directly to results
+			// Keep `i` a string if there are no elements so `matchedCount` will be "00" below
+			for ( ; (elem = elems[i]) != null; i++ ) {
+				if ( byElement && elem ) {
+					j = 0;
+					while ( (matcher = elementMatchers[j++]) ) {
+						if ( matcher( elem, context, xml ) ) {
+							results.push( elem );
+							break;
+						}
+					}
+					if ( outermost ) {
+						dirruns = dirrunsUnique;
+						cachedruns = ++matcherCachedRuns;
+					}
+				}
+
+				// 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 );
+					}
+				}
+			}
+
+			// Apply set filters to unmatched elements
+			matchedCount += i;
+			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 ) {
+
+					Sizzle.uniqueSort( results );
+				}
+			}
+
+			// Override manipulation of globals by nested matchers
+			if ( outermost ) {
+				dirruns = dirrunsUnique;
+				outermostContext = contextBackup;
+			}
+
+			return unmatched;
+		};
+
+	return bySet ?
+		markFunction( superMatcher ) :
+		superMatcher;
+}
+
+compile = Sizzle.compile = function( selector, group /* 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 ( !group ) {
+			group = tokenize( selector );
+		}
+		i = group.length;
+		while ( i-- ) {
+			cached = matcherFromTokens( group[i] );
+			if ( cached[ expando ] ) {
+				setMatchers.push( cached );
+			} else {
+				elementMatchers.push( cached );
+			}
+		}
+
+		// Cache the compiled function
+		cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
+	}
+	return cached;
+};
+
+function multipleContexts( selector, contexts, results ) {
+	var i = 0,
+		len = contexts.length;
+	for ( ; i < len; i++ ) {
+		Sizzle( selector, contexts[i], results );
+	}
+	return results;
+}
+
+function select( selector, context, results, seed ) {
+	var i, tokens, token, type, find,
+		match = tokenize( selector );
+
+	if ( !seed ) {
+		// Try to minimize operations if there is only one group
+		if ( match.length === 1 ) {
+
+			// Take a shortcut and set the context if the root selector is an ID
+			tokens = match[0] = match[0].slice( 0 );
+			if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
+					context.nodeType === 9 && !documentIsXML &&
+					Expr.relative[ tokens[1].type ] ) {
+
+				context = Expr.find["ID"]( token.matches[0].replace( runescape, funescape ), context )[0];
+				if ( !context ) {
+					return results;
+				}
+
+				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 ) && 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, slice.call( seed, 0 ) );
+							return results;
+						}
+
+						break;
+					}
+				}
+			}
+		}
+	}
+
+	// Compile and execute a filtering function
+	// Provide `match` to avoid retokenization if we modified the selector above
+	compile( selector, match )(
+		seed,
+		context,
+		documentIsXML,
+		results,
+		rsibling.test( selector )
+	);
+	return results;
+}
+
+// Deprecated
+Expr.pseudos["nth"] = Expr.pseudos["eq"];
+
+// Easy API for creating new setFilters
+function setFilters() {}
+Expr.filters = setFilters.prototype = Expr.pseudos;
+Expr.setFilters = new setFilters();
+
+// Initialize with the default document
+setDocument();
+
+// Override sizzle attribute retrieval
+Sizzle.attr = jQuery.attr;
+jQuery.find = Sizzle;
+jQuery.expr = Sizzle.selectors;
+jQuery.expr[":"] = jQuery.expr.pseudos;
+jQuery.unique = Sizzle.uniqueSort;
+jQuery.text = Sizzle.getText;
+jQuery.isXMLDoc = Sizzle.isXML;
+jQuery.contains = Sizzle.contains;
+
+
+})( window );
+var runtil = /Until$/,
+	rparentsprev = /^(?:parents|prev(?:Until|All))/,
+	isSimple = /^.[^:#\[\.,]*$/,
+	rneedsContext = jQuery.expr.match.needsContext,
+	// 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({
+	find: function( selector ) {
+		var i, ret, self,
+			len = this.length;
+
+		if ( typeof selector !== "string" ) {
+			self = this;
+			return this.pushStack( jQuery( selector ).filter(function() {
+				for ( i = 0; i < len; i++ ) {
+					if ( jQuery.contains( self[ i ], this ) ) {
+						return true;
+					}
+				}
+			}) );
+		}
+
+		ret = [];
+		for ( i = 0; i < len; i++ ) {
+			jQuery.find( selector, this[ i ], ret );
+		}
+
+		// Needed because $( selector, context ) becomes $( context ).find( selector )
+		ret = this.pushStack( len > 1 ? jQuery.unique( ret ) : ret );
+		ret.selector = ( this.selector ? this.selector + " " : "" ) + selector;
+		return ret;
+	},
+
+	has: function( target ) {
+		var i,
+			targets = jQuery( target, this ),
+			len = targets.length;
+
+		return this.filter(function() {
+			for ( i = 0; i < len; i++ ) {
+				if ( jQuery.contains( this, targets[i] ) ) {
+					return true;
+				}
+			}
+		});
+	},
+
+	not: function( selector ) {
+		return this.pushStack( winnow(this, selector, false) );
+	},
+
+	filter: function( selector ) {
+		return this.pushStack( winnow(this, selector, true) );
+	},
+
+	is: function( selector ) {
+		return !!selector && (
+			typeof selector === "string" ?
+				// 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".
+				rneedsContext.test( selector ) ?
+					jQuery( selector, this.context ).index( this[0] ) >= 0 :
+					jQuery.filter( selector, this ).length > 0 :
+				this.filter( selector ).length > 0 );
+	},
+
+	closest: function( selectors, context ) {
+		var cur,
+			i = 0,
+			l = this.length,
+			ret = [],
+			pos = rneedsContext.test( selectors ) || typeof selectors !== "string" ?
+				jQuery( selectors, context || this.context ) :
+				0;
+
+		for ( ; i < l; i++ ) {
+			cur = this[i];
+
+			while ( cur && cur.ownerDocument && cur !== context && cur.nodeType !== 11 ) {
+				if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) {
+					ret.push( cur );
+					break;
+				}
+				cur = cur.parentNode;
+			}
+		}
+
+		return this.pushStack( ret.length > 1 ? jQuery.unique( ret ) : ret );
+	},
+
+	// Determine the position of an element within
+	// the matched set of elements
+	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 jQuery.inArray( this[0], jQuery( elem ) );
+		}
+
+		// Locate the position of the desired element
+		return jQuery.inArray(
+			// If it receives a jQuery object, the first element is used
+			elem.jquery ? elem[0] : elem, this );
+	},
+
+	add: function( selector, context ) {
+		var set = typeof selector === "string" ?
+				jQuery( selector, context ) :
+				jQuery.makeArray( selector && selector.nodeType ? [ selector ] : selector ),
+			all = jQuery.merge( this.get(), set );
+
+		return this.pushStack( jQuery.unique(all) );
+	},
+
+	addBack: function( selector ) {
+		return this.add( selector == null ?
+			this.prevObject : this.prevObject.filter(selector)
+		);
+	}
+});
+
+jQuery.fn.andSelf = jQuery.fn.addBack;
+
+function sibling( cur, dir ) {
+	do {
+		cur = cur[ dir ];
+	} while ( cur && 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 jQuery.dir( elem, "parentNode" );
+	},
+	parentsUntil: function( elem, i, until ) {
+		return jQuery.dir( elem, "parentNode", until );
+	},
+	next: function( elem ) {
+		return sibling( elem, "nextSibling" );
+	},
+	prev: function( elem ) {
+		return sibling( elem, "previousSibling" );
+	},
+	nextAll: function( elem ) {
+		return jQuery.dir( elem, "nextSibling" );
+	},
+	prevAll: function( elem ) {
+		return jQuery.dir( elem, "previousSibling" );
+	},
+	nextUntil: function( elem, i, until ) {
+		return jQuery.dir( elem, "nextSibling", until );
+	},
+	prevUntil: function( elem, i, until ) {
+		return jQuery.dir( elem, "previousSibling", until );
+	},
+	siblings: function( elem ) {
+		return jQuery.sibling( ( elem.parentNode || {} ).firstChild, elem );
+	},
+	children: function( elem ) {
+		return jQuery.sibling( elem.firstChild );
+	},
+	contents: function( elem ) {
+		return jQuery.nodeName( elem, "iframe" ) ?
+			elem.contentDocument || elem.contentWindow.document :
+			jQuery.merge( [], elem.childNodes );
+	}
+}, function( name, fn ) {
+	jQuery.fn[ name ] = function( until, selector ) {
+		var ret = jQuery.map( this, fn, until );
+
+		if ( !runtil.test( name ) ) {
+			selector = until;
+		}
+
+		if ( selector && typeof selector === "string" ) {
+			ret = jQuery.filter( selector, ret );
+		}
+
+		ret = this.length > 1 && !guaranteedUnique[ name ] ? jQuery.unique( ret ) : ret;
+
+		if ( this.length > 1 && rparentsprev.test( name ) ) {
+			ret = ret.reverse();
+		}
+
+		return this.pushStack( ret );
+	};
+});
+
+jQuery.extend({
+	filter: function( expr, elems, not ) {
+		if ( not ) {
+			expr = ":not(" + expr + ")";
+		}
+
+		return elems.length === 1 ?
+			jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] :
+			jQuery.find.matches(expr, elems);
+	},
+
+	dir: function( elem, dir, until ) {
+		var matched = [],
+			cur = elem[ dir ];
+
+		while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {
+			if ( cur.nodeType === 1 ) {
+				matched.push( cur );
+			}
+			cur = cur[dir];
+		}
+		return matched;
+	},
+
+	sibling: function( n, elem ) {
+		var r = [];
+
+		for ( ; n; n = n.nextSibling ) {
+			if ( n.nodeType === 1 && n !== elem ) {
+				r.push( n );
+			}
+		}
+
+		return r;
+	}
+});
+
+// Implement the identical functionality for filter and not
+function winnow( elements, qualifier, keep ) {
+
+	// Can't pass null or undefined to indexOf in Firefox 4
+	// Set to 0 to skip string check
+	qualifier = qualifier || 0;
+
+	if ( jQuery.isFunction( qualifier ) ) {
+		return jQuery.grep(elements, function( elem, i ) {
+			var retVal = !!qualifier.call( elem, i, elem );
+			return retVal === keep;
+		});
+
+	} else if ( qualifier.nodeType ) {
+		return jQuery.grep(elements, function( elem ) {
+			return ( elem === qualifier ) === keep;
+		});
+
+	} else if ( typeof qualifier === "string" ) {
+		var filtered = jQuery.grep(elements, function( elem ) {
+			return elem.nodeType === 1;
+		});
+
+		if ( isSimple.test( qualifier ) ) {
+			return jQuery.filter(qualifier, filtered, !keep);
+		} else {
+			qualifier = jQuery.filter( qualifier, filtered );
+		}
+	}
+
+	return jQuery.grep(elements, function( elem ) {
+		return ( jQuery.inArray( elem, qualifier ) >= 0 ) === keep;
+	});
+}
+function createSafeFragment( document ) {
+	var list = nodeNames.split( "|" ),
+		safeFrag = document.createDocumentFragment();
+
+	if ( safeFrag.createElement ) {
+		while ( list.length ) {
+			safeFrag.createElement(
+				list.pop()
+			);
+		}
+	}
+	return safeFrag;
+}
+
+var nodeNames = "abbr|article|aside|audio|bdi|canvas|data|datalist|details|figcaption|figure|footer|" +
+		"header|hgroup|mark|meter|nav|output|progress|section|summary|time|video",
+	rinlinejQuery = / jQuery\d+="(?:null|\d+)"/g,
+	rnoshimcache = new RegExp("<(?:" + nodeNames + ")[\\s/>]", "i"),
+	rleadingWhitespace = /^\s+/,
+	rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi,
+	rtagName = /<([\w:]+)/,
+	rtbody = /<tbody/i,
+	rhtml = /<|&#?\w+;/,
+	rnoInnerhtml = /<(?:script|style|link)/i,
+	manipulation_rcheckableType = /^(?:checkbox|radio)$/i,
+	// checked="checked" or checked
+	rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
+	rscriptType = /^$|\/(?:java|ecma)script/i,
+	rscriptTypeMasked = /^true\/(.*)/,
+	rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g,
+
+	// We have to close these tags to support XHTML (#13200)
+	wrapMap = {
+		option: [ 1, "<select multiple='multiple'>", "</select>" ],
+		legend: [ 1, "<fieldset>", "</fieldset>" ],
+		area: [ 1, "<map>", "</map>" ],
+		param: [ 1, "<object>", "</object>" ],
+		thead: [ 1, "<table>", "</table>" ],
+		tr: [ 2, "<table><tbody>", "</tbody></table>" ],
+		col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
+		td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
+
+		// IE6-8 can't serialize link, script, style, or any html5 (NoScope) tags,
+		// unless wrapped in a div with non-breaking characters in front of it.
+		_default: jQuery.support.htmlSerialize ? [ 0, "", "" ] : [ 1, "X<div>", "</div>"  ]
+	},
+	safeFragment = createSafeFragment( document ),
+	fragmentDiv = safeFragment.appendChild( document.createElement("div") );
+
+wrapMap.optgroup = wrapMap.option;
+wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
+wrapMap.th = wrapMap.td;
+
+jQuery.fn.extend({
+	text: function( value ) {
+		return jQuery.access( this, function( value ) {
+			return value === undefined ?
+				jQuery.text( this ) :
+				this.empty().append( ( this[0] && this[0].ownerDocument || document ).createTextNode( value ) );
+		}, null, value, arguments.length );
+	},
+
+	wrapAll: function( html ) {
+		if ( jQuery.isFunction( html ) ) {
+			return this.each(function(i) {
+				jQuery(this).wrapAll( html.call(this, i) );
+			});
+		}
+
+		if ( this[0] ) {
+			// The elements to wrap the target around
+			var 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.firstChild && elem.firstChild.nodeType === 1 ) {
+					elem = elem.firstChild;
+				}
+
+				return elem;
+			}).append( this );
+		}
+
+		return this;
+	},
+
+	wrapInner: function( html ) {
+		if ( jQuery.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 isFunction = jQuery.isFunction( html );
+
+		return this.each(function(i) {
+			jQuery( this ).wrapAll( isFunction ? html.call(this, i) : html );
+		});
+	},
+
+	unwrap: function() {
+		return this.parent().each(function() {
+			if ( !jQuery.nodeName( this, "body" ) ) {
+				jQuery( this ).replaceWith( this.childNodes );
+			}
+		}).end();
+	},
+
+	append: function() {
+		return this.domManip(arguments, true, function( elem ) {
+			if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
+				this.appendChild( elem );
+			}
+		});
+	},
+
+	prepend: function() {
+		return this.domManip(arguments, true, function( elem ) {
+			if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
+				this.insertBefore( elem, this.firstChild );
+			}
+		});
+	},
+
+	before: function() {
+		return this.domManip( arguments, false, function( elem ) {
+			if ( this.parentNode ) {
+				this.parentNode.insertBefore( elem, this );
+			}
+		});
+	},
+
+	after: function() {
+		return this.domManip( arguments, false, function( elem ) {
+			if ( this.parentNode ) {
+				this.parentNode.insertBefore( elem, this.nextSibling );
+			}
+		});
+	},
+
+	// keepData is for internal use only--do not document
+	remove: function( selector, keepData ) {
+		var elem,
+			i = 0;
+
+		for ( ; (elem = this[i]) != null; i++ ) {
+			if ( !selector || jQuery.filter( selector, [ elem ] ).length > 0 ) {
+				if ( !keepData && elem.nodeType === 1 ) {
+					jQuery.cleanData( getAll( elem ) );
+				}
+
+				if ( elem.parentNode ) {
+					if ( keepData && jQuery.contains( elem.ownerDocument, elem ) ) {
+						setGlobalEval( getAll( elem, "script" ) );
+					}
+					elem.parentNode.removeChild( elem );
+				}
+			}
+		}
+
+		return this;
+	},
+
+	empty: function() {
+		var elem,
+			i = 0;
+
+		for ( ; (elem = this[i]) != null; i++ ) {
+			// Remove element nodes and prevent memory leaks
+			if ( elem.nodeType === 1 ) {
+				jQuery.cleanData( getAll( elem, false ) );
+			}
+
+			// Remove any remaining nodes
+			while ( elem.firstChild ) {
+				elem.removeChild( elem.firstChild );
+			}
+
+			// If this is a select, ensure that it displays empty (#12336)
+			// Support: IE<9
+			if ( elem.options && jQuery.nodeName( elem, "select" ) ) {
+				elem.options.length = 0;
+			}
+		}
+
+		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 jQuery.access( this, function( value ) {
+			var elem = this[0] || {},
+				i = 0,
+				l = this.length;
+
+			if ( value === undefined ) {
+				return elem.nodeType === 1 ?
+					elem.innerHTML.replace( rinlinejQuery, "" ) :
+					undefined;
+			}
+
+			// See if we can take a shortcut and just use innerHTML
+			if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
+				( jQuery.support.htmlSerialize || !rnoshimcache.test( value )  ) &&
+				( jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value ) ) &&
+				!wrapMap[ ( rtagName.exec( value ) || ["", ""] )[1].toLowerCase() ] ) {
+
+				value = value.replace( rxhtmlTag, "<$1></$2>" );
+
+				try {
+					for (; i < l; i++ ) {
+						// Remove element nodes and prevent memory leaks
+						elem = this[i] || {};
+						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( value ) {
+		var isFunc = jQuery.isFunction( value );
+
+		// Make sure that the elements are removed from the DOM before they are inserted
+		// this can help fix replacing a parent with child elements
+		if ( !isFunc && typeof value !== "string" ) {
+			value = jQuery( value ).not( this ).detach();
+		}
+
+		return this.domManip( [ value ], true, function( elem ) {
+			var next = this.nextSibling,
+				parent = this.parentNode;
+
+			if ( parent ) {
+				jQuery( this ).remove();
+				parent.insertBefore( elem, next );
+			}
+		});
+	},
+
+	detach: function( selector ) {
+		return this.remove( selector, true );
+	},
+
+	domManip: function( args, table, callback ) {
+
+		// Flatten any nested arrays
+		args = core_concat.apply( [], args );
+
+		var first, node, hasScripts,
+			scripts, doc, fragment,
+			i = 0,
+			l = this.length,
+			set = this,
+			iNoClone = l - 1,
+			value = args[0],
+			isFunction = jQuery.isFunction( value );
+
+		// We can't cloneNode fragments that contain checked, in WebKit
+		if ( isFunction || !( l <= 1 || typeof value !== "string" || jQuery.support.checkClone || !rchecked.test( value ) ) ) {
+			return this.each(function( index ) {
+				var self = set.eq( index );
+				if ( isFunction ) {
+					args[0] = value.call( this, index, table ? self.html() : undefined );
+				}
+				self.domManip( args, table, callback );
+			});
+		}
+
+		if ( l ) {
+			fragment = jQuery.buildFragment( args, this[ 0 ].ownerDocument, false, this );
+			first = fragment.firstChild;
+
+			if ( fragment.childNodes.length === 1 ) {
+				fragment = first;
+			}
+
+			if ( first ) {
+				table = table && jQuery.nodeName( first, "tr" );
+				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 (#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 ) {
+							jQuery.merge( scripts, getAll( node, "script" ) );
+						}
+					}
+
+					callback.call(
+						table && jQuery.nodeName( this[i], "table" ) ?
+							findOrAppend( this[i], "tbody" ) :
+							this[i],
+						node,
+						i
+					);
+				}
+
+				if ( hasScripts ) {
+					doc = scripts[ scripts.length - 1 ].ownerDocument;
+
+					// Reenable 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 || "" ) &&
+							!jQuery._data( node, "globalEval" ) && jQuery.contains( doc, node ) ) {
+
+							if ( node.src ) {
+								// Hope ajax is available...
+								jQuery.ajax({
+									url: node.src,
+									type: "GET",
+									dataType: "script",
+									async: false,
+									global: false,
+									"throws": true
+								});
+							} else {
+								jQuery.globalEval( ( node.text || node.textContent || node.innerHTML || "" ).replace( rcleanScript, "" ) );
+							}
+						}
+					}
+				}
+
+				// Fix #11809: Avoid leaking memory
+				fragment = first = null;
+			}
+		}
+
+		return this;
+	}
+});
+
+function findOrAppend( elem, tag ) {
+	return elem.getElementsByTagName( tag )[0] || elem.appendChild( elem.ownerDocument.createElement( tag ) );
+}
+
+// Replace/restore the type attribute of script elements for safe DOM manipulation
+function disableScript( elem ) {
+	var attr = elem.getAttributeNode("type");
+	elem.type = ( attr && attr.specified ) + "/" + elem.type;
+	return elem;
+}
+function restoreScript( elem ) {
+	var match = rscriptTypeMasked.exec( elem.type );
+	if ( match ) {
+		elem.type = match[1];
+	} else {
+		elem.removeAttribute("type");
+	}
+	return elem;
+}
+
+// Mark scripts as having already been evaluated
+function setGlobalEval( elems, refElements ) {
+	var elem,
+		i = 0;
+	for ( ; (elem = elems[i]) != null; i++ ) {
+		jQuery._data( elem, "globalEval", !refElements || jQuery._data( refElements[i], "globalEval" ) );
+	}
+}
+
+function cloneCopyEvent( src, dest ) {
+
+	if ( dest.nodeType !== 1 || !jQuery.hasData( src ) ) {
+		return;
+	}
+
+	var type, i, l,
+		oldData = jQuery._data( src ),
+		curData = jQuery._data( dest, oldData ),
+		events = oldData.events;
+
+	if ( events ) {
+		delete curData.handle;
+		curData.events = {};
+
+		for ( type in events ) {
+			for ( i = 0, l = events[ type ].length; i < l; i++ ) {
+				jQuery.event.add( dest, type, events[ type ][ i ] );
+			}
+		}
+	}
+
+	// make the cloned public data object a copy from the original
+	if ( curData.data ) {
+		curData.data = jQuery.extend( {}, curData.data );
+	}
+}
+
+function fixCloneNodeIssues( src, dest ) {
+	var nodeName, e, data;
+
+	// We do not need to do anything for non-Elements
+	if ( dest.nodeType !== 1 ) {
+		return;
+	}
+
+	nodeName = dest.nodeName.toLowerCase();
+
+	// IE6-8 copies events bound via attachEvent when using cloneNode.
+	if ( !jQuery.support.noCloneEvent && dest[ jQuery.expando ] ) {
+		data = jQuery._data( dest );
+
+		for ( e in data.events ) {
+			jQuery.removeEvent( dest, e, data.handle );
+		}
+
+		// Event data gets referenced instead of copied if the expando gets copied too
+		dest.removeAttribute( jQuery.expando );
+	}
+
+	// IE blanks contents when cloning scripts, and tries to evaluate newly-set text
+	if ( nodeName === "script" && dest.text !== src.text ) {
+		disableScript( dest ).text = src.text;
+		restoreScript( dest );
+
+	// IE6-10 improperly clones children of object elements using classid.
+	// IE10 throws NoModificationAllowedError if parent is null, #12132.
+	} else if ( nodeName === "object" ) {
+		if ( dest.parentNode ) {
+			dest.outerHTML = src.outerHTML;
+		}
+
+		// This path appears unavoidable for IE9. When cloning an object
+		// element in IE9, the outerHTML strategy above is not sufficient.
+		// If the src has innerHTML and the destination does not,
+		// copy the src.innerHTML into the dest.innerHTML. #10324
+		if ( jQuery.support.html5Clone && ( src.innerHTML && !jQuery.trim(dest.innerHTML) ) ) {
+			dest.innerHTML = src.innerHTML;
+		}
+
+	} else if ( nodeName === "input" && manipulation_rcheckableType.test( src.type ) ) {
+		// IE6-8 fails to persist the checked state of a cloned checkbox
+		// or radio button. Worse, IE6-7 fail to give the cloned element
+		// a checked appearance if the defaultChecked value isn't also set
+
+		dest.defaultChecked = dest.checked = src.checked;
+
+		// IE6-7 get confused and end up setting the value of a cloned
+		// checkbox/radio button to an empty string instead of "on"
+		if ( dest.value !== src.value ) {
+			dest.value = src.value;
+		}
+
+	// IE6-8 fails to return the selected option to the default selected
+	// state when cloning options
+	} else if ( nodeName === "option" ) {
+		dest.defaultSelected = dest.selected = src.defaultSelected;
+
+	// IE6-8 fails to set the defaultValue to the correct value when
+	// cloning other types of input fields
+	} else if ( nodeName === "input" || nodeName === "textarea" ) {
+		dest.defaultValue = src.defaultValue;
+	}
+}
+
+jQuery.each({
+	appendTo: "append",
+	prependTo: "prepend",
+	insertBefore: "before",
+	insertAfter: "after",
+	replaceAll: "replaceWith"
+}, function( name, original ) {
+	jQuery.fn[ name ] = function( selector ) {
+		var elems,
+			i = 0,
+			ret = [],
+			insert = jQuery( selector ),
+			last = insert.length - 1;
+
+		for ( ; i <= last; i++ ) {
+			elems = i === last ? this : this.clone(true);
+			jQuery( insert[i] )[ original ]( elems );
+
+			// Modern browsers can apply jQuery collections as arrays, but oldIE needs a .get()
+			core_push.apply( ret, elems.get() );
+		}
+
+		return this.pushStack( ret );
+	};
+});
+
+function getAll( context, tag ) {
+	var elems, elem,
+		i = 0,
+		found = typeof context.getElementsByTagName !== core_strundefined ? context.getElementsByTagName( tag || "*" ) :
+			typeof context.querySelectorAll !== core_strundefined ? context.querySelectorAll( tag || "*" ) :
+			undefined;
+
+	if ( !found ) {
+		for ( found = [], elems = context.childNodes || context; (elem = elems[i]) != null; i++ ) {
+			if ( !tag || jQuery.nodeName( elem, tag ) ) {
+				found.push( elem );
+			} else {
+				jQuery.merge( found, getAll( elem, tag ) );
+			}
+		}
+	}
+
+	return tag === undefined || tag && jQuery.nodeName( context, tag ) ?
+		jQuery.merge( [ context ], found ) :
+		found;
+}
+
+// Used in buildFragment, fixes the defaultChecked property
+function fixDefaultChecked( elem ) {
+	if ( manipulation_rcheckableType.test( elem.type ) ) {
+		elem.defaultChecked = elem.checked;
+	}
+}
+
+jQuery.extend({
+	clone: function( elem, dataAndEvents, deepDataAndEvents ) {
+		var destElements, node, clone, i, srcElements,
+			inPage = jQuery.contains( elem.ownerDocument, elem );
+
+		if ( jQuery.support.html5Clone || jQuery.isXMLDoc(elem) || !rnoshimcache.test( "<" + elem.nodeName + ">" ) ) {
+			clone = elem.cloneNode( true );
+
+		// IE<=8 does not properly clone detached, unknown element nodes
+		} else {
+			fragmentDiv.innerHTML = elem.outerHTML;
+			fragmentDiv.removeChild( clone = fragmentDiv.firstChild );
+		}
+
+		if ( (!jQuery.support.noCloneEvent || !jQuery.support.noCloneChecked) &&
+				(elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem) ) {
+
+			// We eschew Sizzle here for performance reasons: http://jsperf.com/getall-vs-sizzle/2
+			destElements = getAll( clone );
+			srcElements = getAll( elem );
+
+			// Fix all IE cloning issues
+			for ( i = 0; (node = srcElements[i]) != null; ++i ) {
+				// Ensure that the destination node is not null; Fixes #9587
+				if ( destElements[i] ) {
+					fixCloneNodeIssues( node, 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; (node = srcElements[i]) != null; i++ ) {
+					cloneCopyEvent( node, destElements[i] );
+				}
+			} else {
+				cloneCopyEvent( elem, clone );
+			}
+		}
+
+		// Preserve script evaluation history
+		destElements = getAll( clone, "script" );
+		if ( destElements.length > 0 ) {
+			setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );
+		}
+
+		destElements = srcElements = node = null;
+
+		// Return the cloned set
+		return clone;
+	},
+
+	buildFragment: function( elems, context, scripts, selection ) {
+		var j, elem, contains,
+			tmp, tag, tbody, wrap,
+			l = elems.length,
+
+			// Ensure a safe fragment
+			safe = createSafeFragment( context ),
+
+			nodes = [],
+			i = 0;
+
+		for ( ; i < l; i++ ) {
+			elem = elems[ i ];
+
+			if ( elem || elem === 0 ) {
+
+				// Add nodes directly
+				if ( jQuery.type( elem ) === "object" ) {
+					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 || safe.appendChild( context.createElement("div") );
+
+					// Deserialize a standard representation
+					tag = ( rtagName.exec( elem ) || ["", ""] )[1].toLowerCase();
+					wrap = wrapMap[ tag ] || wrapMap._default;
+
+					tmp.innerHTML = wrap[1] + elem.replace( rxhtmlTag, "<$1></$2>" ) + wrap[2];
+
+					// Descend through wrappers to the right content
+					j = wrap[0];
+					while ( j-- ) {
+						tmp = tmp.lastChild;
+					}
+
+					// Manually add leading whitespace removed by IE
+					if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
+						nodes.push( context.createTextNode( rleadingWhitespace.exec( elem )[0] ) );
+					}
+
+					// Remove IE's autoinserted <tbody> from table fragments
+					if ( !jQuery.support.tbody ) {
+
+						// String was a <table>, *may* have spurious <tbody>
+						elem = tag === "table" && !rtbody.test( elem ) ?
+							tmp.firstChild :
+
+							// String was a bare <thead> or <tfoot>
+							wrap[1] === "<table>" && !rtbody.test( elem ) ?
+								tmp :
+								0;
+
+						j = elem && elem.childNodes.length;
+						while ( j-- ) {
+							if ( jQuery.nodeName( (tbody = elem.childNodes[j]), "tbody" ) && !tbody.childNodes.length ) {
+								elem.removeChild( tbody );
+							}
+						}
+					}
+
+					jQuery.merge( nodes, tmp.childNodes );
+
+					// Fix #12392 for WebKit and IE > 9
+					tmp.textContent = "";
+
+					// Fix #12392 for oldIE
+					while ( tmp.firstChild ) {
+						tmp.removeChild( tmp.firstChild );
+					}
+
+					// Remember the top-level container for proper cleanup
+					tmp = safe.lastChild;
+				}
+			}
+		}
+
+		// Fix #11356: Clear elements from fragment
+		if ( tmp ) {
+			safe.removeChild( tmp );
+		}
+
+		// Reset defaultChecked for any radios and checkboxes
+		// about to be appended to the DOM in IE 6/7 (#8060)
+		if ( !jQuery.support.appendChecked ) {
+			jQuery.grep( getAll( nodes, "input" ), fixDefaultChecked );
+		}
+
+		i = 0;
+		while ( (elem = nodes[ i++ ]) ) {
+
+			// #4087 - If origin and destination elements are the same, and this is
+			// that element, do not do anything
+			if ( selection && jQuery.inArray( elem, selection ) !== -1 ) {
+				continue;
+			}
+
+			contains = jQuery.contains( elem.ownerDocument, elem );
+
+			// Append to fragment
+			tmp = getAll( safe.appendChild( elem ), "script" );
+
+			// Preserve script evaluation history
+			if ( contains ) {
+				setGlobalEval( tmp );
+			}
+
+			// Capture executables
+			if ( scripts ) {
+				j = 0;
+				while ( (elem = tmp[ j++ ]) ) {
+					if ( rscriptType.test( elem.type || "" ) ) {
+						scripts.push( elem );
+					}
+				}
+			}
+		}
+
+		tmp = null;
+
+		return safe;
+	},
+
+	cleanData: function( elems, /* internal */ acceptData ) {
+		var elem, type, id, data,
+			i = 0,
+			internalKey = jQuery.expando,
+			cache = jQuery.cache,
+			deleteExpando = jQuery.support.deleteExpando,
+			special = jQuery.event.special;
+
+		for ( ; (elem = elems[i]) != null; i++ ) {
+
+			if ( acceptData || jQuery.acceptData( elem ) ) {
+
+				id = elem[ internalKey ];
+				data = id && cache[ id ];
+
+				if ( data ) {
+					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 );
+							}
+						}
+					}
+
+					// Remove cache only if it was not already removed by jQuery.event.remove
+					if ( cache[ id ] ) {
+
+						delete cache[ id ];
+
+						// IE does not allow us to delete expando properties from nodes,
+						// nor does it have a removeAttribute function on Document nodes;
+						// we must handle all of these cases
+						if ( deleteExpando ) {
+							delete elem[ internalKey ];
+
+						} else if ( typeof elem.removeAttribute !== core_strundefined ) {
+							elem.removeAttribute( internalKey );
+
+						} else {
+							elem[ internalKey ] = null;
+						}
+
+						core_deletedIds.push( id );
+					}
+				}
+			}
+		}
+	}
+});
+var iframe, getStyles, curCSS,
+	ralpha = /alpha\([^)]*\)/i,
+	ropacity = /opacity\s*=\s*([^)]*)/,
+	rposition = /^(top|right|bottom|left)$/,
+	// 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]).+)/,
+	rmargin = /^margin/,
+	rnumsplit = new RegExp( "^(" + core_pnum + ")(.*)$", "i" ),
+	rnumnonpx = new RegExp( "^(" + core_pnum + ")(?!px)[a-z%]+$", "i" ),
+	rrelNum = new RegExp( "^([+-])=(" + core_pnum + ")", "i" ),
+	elemdisplay = { BODY: "block" },
+
+	cssShow = { position: "absolute", visibility: "hidden", display: "block" },
+	cssNormalTransform = {
+		letterSpacing: 0,
+		fontWeight: 400
+	},
+
+	cssExpand = [ "Top", "Right", "Bottom", "Left" ],
+	cssPrefixes = [ "Webkit", "O", "Moz", "ms" ];
+
+// return a css property mapped to a potentially vendor prefixed property
+function vendorPropName( style, name ) {
+
+	// shortcut for names that are not vendor prefixed
+	if ( name in style ) {
+		return name;
+	}
+
+	// check for vendor prefixed names
+	var capName = name.charAt(0).toUpperCase() + name.slice(1),
+		origName = name,
+		i = cssPrefixes.length;
+
+	while ( i-- ) {
+		name = cssPrefixes[ i ] + capName;
+		if ( name in style ) {
+			return name;
+		}
+	}
+
+	return origName;
+}
+
+function isHidden( elem, el ) {
+	// isHidden might be called from jQuery#filter function;
+	// in that case, element will be second argument
+	elem = el || elem;
+	return jQuery.css( elem, "display" ) === "none" || !jQuery.contains( elem.ownerDocument, elem );
+}
+
+function showHide( elements, show ) {
+	var display, elem, hidden,
+		values = [],
+		index = 0,
+		length = elements.length;
+
+	for ( ; index < length; index++ ) {
+		elem = elements[ index ];
+		if ( !elem.style ) {
+			continue;
+		}
+
+		values[ index ] = jQuery._data( elem, "olddisplay" );
+		display = elem.style.display;
+		if ( show ) {
+			// Reset the inline display of this element to learn if it is
+			// being hidden by cascaded rules or not
+			if ( !values[ index ] && display === "none" ) {
+				elem.style.display = "";
+			}
+
+			// Set elements which have been overridden with display: none
+			// in a stylesheet to whatever the default browser style is
+			// for such an element
+			if ( elem.style.display === "" && isHidden( elem ) ) {
+				values[ index ] = jQuery._data( elem, "olddisplay", css_defaultDisplay(elem.nodeName) );
+			}
+		} else {
+
+			if ( !values[ index ] ) {
+				hidden = isHidden( elem );
+
+				if ( display && display !== "none" || !hidden ) {
+					jQuery._data( elem, "olddisplay", hidden ? display : jQuery.css( elem, "display" ) );
+				}
+			}
+		}
+	}
+
+	// Set the display of most of the elements in a second loop
+	// to avoid the constant reflow
+	for ( index = 0; index < length; index++ ) {
+		elem = elements[ index ];
+		if ( !elem.style ) {
+			continue;
+		}
+		if ( !show || elem.style.display === "none" || elem.style.display === "" ) {
+			elem.style.display = show ? values[ index ] || "" : "none";
+		}
+	}
+
+	return elements;
+}
+
+jQuery.fn.extend({
+	css: function( name, value ) {
+		return jQuery.access( this, function( elem, name, value ) {
+			var len, styles,
+				map = {},
+				i = 0;
+
+			if ( jQuery.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 );
+	},
+	show: function() {
+		return showHide( this, true );
+	},
+	hide: function() {
+		return showHide( this );
+	},
+	toggle: function( state ) {
+		var bool = typeof state === "boolean";
+
+		return this.each(function() {
+			if ( bool ? state : isHidden( this ) ) {
+				jQuery( this ).show();
+			} else {
+				jQuery( this ).hide();
+			}
+		});
+	}
+});
+
+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;
+				}
+			}
+		}
+	},
+
+	// Exclude the following css properties to add px
+	cssNumber: {
+		"columnCount": true,
+		"fillOpacity": true,
+		"fontWeight": true,
+		"lineHeight": true,
+		"opacity": true,
+		"orphans": true,
+		"widows": true,
+		"zIndex": true,
+		"zoom": true
+	},
+
+	// Add in properties whose names you wish to fix before
+	// setting or getting the value
+	cssProps: {
+		// normalize float css property
+		"float": jQuery.support.cssFloat ? "cssFloat" : "styleFloat"
+	},
+
+	// 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 = jQuery.camelCase( name ),
+			style = elem.style;
+
+		name = jQuery.cssProps[ origName ] || ( jQuery.cssProps[ origName ] = vendorPropName( style, origName ) );
+
+		// gets hook for the prefixed version
+		// followed by the unprefixed version
+		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
+
+		// Check if we're setting a value
+		if ( value !== undefined ) {
+			type = typeof value;
+
+			// convert relative number strings (+= or -=) to relative numbers. #7345
+			if ( type === "string" && (ret = rrelNum.exec( value )) ) {
+				value = ( ret[1] + 1 ) * ret[2] + parseFloat( jQuery.css( elem, name ) );
+				// Fixes bug #9237
+				type = "number";
+			}
+
+			// Make sure that NaN and null values aren't set. See: #7116
+			if ( value == null || type === "number" && isNaN( value ) ) {
+				return;
+			}
+
+			// If a number was passed in, add 'px' to the (except for certain CSS properties)
+			if ( type === "number" && !jQuery.cssNumber[ origName ] ) {
+				value += "px";
+			}
+
+			// Fixes #8908, it can be done more correctly by specifing setters in cssHooks,
+			// but it would mean to define eight (for every problematic property) identical functions
+			if ( !jQuery.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 ) {
+
+				// Wrapped to prevent IE from throwing errors when 'invalid' values are provided
+				// Fixes bug #5509
+				try {
+					style[ name ] = value;
+				} catch(e) {}
+			}
+
+		} 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 num, val, hooks,
+			origName = jQuery.camelCase( name );
+
+		// Make sure that we're working with the right name
+		name = jQuery.cssProps[ origName ] || ( jQuery.cssProps[ origName ] = vendorPropName( elem.style, origName ) );
+
+		// gets hook for the prefixed version
+		// followed by the unprefixed version
+		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 ];
+		}
+
+		// Return, converting to number if forced or a qualifier was provided and val looks numeric
+		if ( extra === "" || extra ) {
+			num = parseFloat( val );
+			return extra === true || jQuery.isNumeric( num ) ? num || 0 : val;
+		}
+		return val;
+	},
+
+	// A method for quickly swapping in/out CSS properties to get correct calculations
+	swap: function( elem, options, callback, args ) {
+		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.apply( elem, args || [] );
+
+		// Revert the old values
+		for ( name in options ) {
+			elem.style[ name ] = old[ name ];
+		}
+
+		return ret;
+	}
+});
+
+// NOTE: we've included the "window" in window.getComputedStyle
+// because jsdom on node.js will break without it.
+if ( window.getComputedStyle ) {
+	getStyles = function( elem ) {
+		return window.getComputedStyle( elem, null );
+	};
+
+	curCSS = function( elem, name, _computed ) {
+		var width, minWidth, maxWidth,
+			computed = _computed || getStyles( elem ),
+
+			// getPropertyValue is only needed for .css('filter') in IE9, see #12537
+			ret = computed ? computed.getPropertyValue( name ) || computed[ name ] : undefined,
+			style = elem.style;
+
+		if ( computed ) {
+
+			if ( ret === "" && !jQuery.contains( elem.ownerDocument, elem ) ) {
+				ret = jQuery.style( elem, name );
+			}
+
+			// A tribute to the "awesome hack by Dean Edwards"
+			// Chrome < 17 and Safari 5.0 uses "computed value" instead of "used value" for margin-right
+			// Safari 5.1.7 (at least) returns percentage for a larger set of values, but width seems to be reliably pixels
+			// this is against the CSSOM draft spec: http://dev.w3.org/csswg/cssom/#resolved-values
+			if ( rnumnonpx.test( ret ) && rmargin.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;
+	};
+} else if ( document.documentElement.currentStyle ) {
+	getStyles = function( elem ) {
+		return elem.currentStyle;
+	};
+
+	curCSS = function( elem, name, _computed ) {
+		var left, rs, rsLeft,
+			computed = _computed || getStyles( elem ),
+			ret = computed ? computed[ name ] : undefined,
+			style = elem.style;
+
+		// Avoid setting ret to empty string here
+		// so we don't default to auto
+		if ( ret == null && style && style[ name ] ) {
+			ret = style[ name ];
+		}
+
+		// From the awesome hack by Dean Edwards
+		// http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
+
+		// If we're not dealing with a regular pixel number
+		// but a number that has a weird ending, we need to convert it to pixels
+		// but not position css attributes, as those are proportional to the parent element instead
+		// and we can't measure the parent instead because it might trigger a "stacking dolls" problem
+		if ( rnumnonpx.test( ret ) && !rposition.test( name ) ) {
+
+			// Remember the original values
+			left = style.left;
+			rs = elem.runtimeStyle;
+			rsLeft = rs && rs.left;
+
+			// Put in the new values to get a computed value out
+			if ( rsLeft ) {
+				rs.left = elem.currentStyle.left;
+			}
+			style.left = name === "fontSize" ? "1em" : ret;
+			ret = style.pixelLeft + "px";
+
+			// Revert the changed values
+			style.left = left;
+			if ( rsLeft ) {
+				rs.left = rsLeft;
+			}
+		}
+
+		return ret === "" ? "auto" : ret;
+	};
+}
+
+function setPositiveNumber( elem, value, subtract ) {
+	var matches = rnumsplit.exec( value );
+	return matches ?
+		// Guard against undefined "subtract", e.g., when used as in cssHooks
+		Math.max( 0, matches[ 1 ] - ( subtract || 0 ) ) + ( matches[ 2 ] || "px" ) :
+		value;
+}
+
+function augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) {
+	var i = extra === ( isBorderBox ? "border" : "content" ) ?
+		// If we already have the right measurement, avoid augmentation
+		4 :
+		// Otherwise initialize for horizontal or vertical properties
+		name === "width" ? 1 : 0,
+
+		val = 0;
+
+	for ( ; i < 4; i += 2 ) {
+		// both box models exclude margin, so add it if we want it
+		if ( extra === "margin" ) {
+			val += jQuery.css( elem, extra + cssExpand[ i ], true, styles );
+		}
+
+		if ( isBorderBox ) {
+			// border-box includes padding, so remove it if we want content
+			if ( extra === "content" ) {
+				val -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
+			}
+
+			// at this point, extra isn't border nor margin, so remove border
+			if ( extra !== "margin" ) {
+				val -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
+			}
+		} else {
+			// at this point, extra isn't content, so add padding
+			val += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
+
+			// at this point, extra isn't content nor padding, so add border
+			if ( extra !== "padding" ) {
+				val += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
+			}
+		}
+	}
+
+	return val;
+}
+
+function getWidthOrHeight( elem, name, extra ) {
+
+	// Start with offset property, which is equivalent to the border-box value
+	var valueIsBorderBox = true,
+		val = name === "width" ? elem.offsetWidth : elem.offsetHeight,
+		styles = getStyles( elem ),
+		isBorderBox = jQuery.support.boxSizing && jQuery.css( elem, "boxSizing", false, styles ) === "border-box";
+
+	// some non-html elements return undefined for offsetWidth, so check for null/undefined
+	// svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285
+	// MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668
+	if ( val <= 0 || val == null ) {
+		// Fall back to computed then uncomputed css if necessary
+		val = curCSS( elem, name, styles );
+		if ( val < 0 || val == null ) {
+			val = elem.style[ name ];
+		}
+
+		// Computed unit is not pixels. Stop here and return.
+		if ( rnumnonpx.test(val) ) {
+			return val;
+		}
+
+		// we need the check for style in case a browser which returns unreliable values
+		// for getComputedStyle silently falls back to the reliable elem.style
+		valueIsBorderBox = isBorderBox && ( jQuery.support.boxSizingReliable || val === elem.style[ name ] );
+
+		// Normalize "", auto, and prepare for extra
+		val = parseFloat( val ) || 0;
+	}
+
+	// use the active box-sizing model to add/subtract irrelevant styles
+	return ( val +
+		augmentWidthOrHeight(
+			elem,
+			name,
+			extra || ( isBorderBox ? "border" : "content" ),
+			valueIsBorderBox,
+			styles
+		)
+	) + "px";
+}
+
+// Try to determine the default display value of an element
+function css_defaultDisplay( nodeName ) {
+	var doc = document,
+		display = elemdisplay[ nodeName ];
+
+	if ( !display ) {
+		display = actualDisplay( nodeName, doc );
+
+		// If the simple way fails, read from inside an iframe
+		if ( display === "none" || !display ) {
+			// Use the already-created iframe if possible
+			iframe = ( iframe ||
+				jQuery("<iframe frameborder='0' width='0' height='0'/>")
+				.css( "cssText", "display:block !important" )
+			).appendTo( doc.documentElement );
+
+			// Always write a new HTML skeleton so Webkit and Firefox don't choke on reuse
+			doc = ( iframe[0].contentWindow || iframe[0].contentDocument ).document;
+			doc.write("<!doctype html><html><body>");
+			doc.close();
+
+			display = actualDisplay( nodeName, doc );
+			iframe.detach();
+		}
+
+		// Store the correct default display
+		elemdisplay[ nodeName ] = display;
+	}
+
+	return display;
+}
+
+// Called ONLY from within css_defaultDisplay
+function actualDisplay( name, doc ) {
+	var elem = jQuery( doc.createElement( name ) ).appendTo( doc.body ),
+		display = jQuery.css( elem[0], "display" );
+	elem.remove();
+	return display;
+}
+
+jQuery.each([ "height", "width" ], function( i, name ) {
+	jQuery.cssHooks[ name ] = {
+		get: function( elem, computed, extra ) {
+			if ( computed ) {
+				// certain elements can have dimension info if we invisibly show them
+				// however, it must have a current display style that would benefit from this
+				return elem.offsetWidth === 0 && rdisplayswap.test( jQuery.css( elem, "display" ) ) ?
+					jQuery.swap( elem, cssShow, function() {
+						return getWidthOrHeight( elem, name, extra );
+					}) :
+					getWidthOrHeight( elem, name, extra );
+			}
+		},
+
+		set: function( elem, value, extra ) {
+			var styles = extra && getStyles( elem );
+			return setPositiveNumber( elem, value, extra ?
+				augmentWidthOrHeight(
+					elem,
+					name,
+					extra,
+					jQuery.support.boxSizing && jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
+					styles
+				) : 0
+			);
+		}
+	};
+});
+
+if ( !jQuery.support.opacity ) {
+	jQuery.cssHooks.opacity = {
+		get: function( elem, computed ) {
+			// IE uses filters for opacity
+			return ropacity.test( (computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "" ) ?
+				( 0.01 * parseFloat( RegExp.$1 ) ) + "" :
+				computed ? "1" : "";
+		},
+
+		set: function( elem, value ) {
+			var style = elem.style,
+				currentStyle = elem.currentStyle,
+				opacity = jQuery.isNumeric( value ) ? "alpha(opacity=" + value * 100 + ")" : "",
+				filter = currentStyle && currentStyle.filter || style.filter || "";
+
+			// IE has trouble with opacity if it does not have layout
+			// Force it by setting the zoom level
+			style.zoom = 1;
+
+			// if setting opacity to 1, and no other filters exist - attempt to remove filter attribute #6652
+			// if value === "", then remove inline opacity #12685
+			if ( ( value >= 1 || value === "" ) &&
+					jQuery.trim( filter.replace( ralpha, "" ) ) === "" &&
+					style.removeAttribute ) {
+
+				// Setting style.filter to null, "" & " " still leave "filter:" in the cssText
+				// if "filter:" is present at all, clearType is disabled, we want to avoid this
+				// style.removeAttribute is IE Only, but so apparently is this code path...
+				style.removeAttribute( "filter" );
+
+				// if there is no filter style applied in a css rule or unset inline opacity, we are done
+				if ( value === "" || currentStyle && !currentStyle.filter ) {
+					return;
+				}
+			}
+
+			// otherwise, set new filter values
+			style.filter = ralpha.test( filter ) ?
+				filter.replace( ralpha, opacity ) :
+				filter + " " + opacity;
+		}
+	};
+}
+
+// These hooks cannot be added until DOM ready because the support test
+// for it is not run until after DOM ready
+jQuery(function() {
+	if ( !jQuery.support.reliableMarginRight ) {
+		jQuery.cssHooks.marginRight = {
+			get: function( elem, computed ) {
+				if ( computed ) {
+					// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
+					// Work around by temporarily setting element display to inline-block
+					return jQuery.swap( elem, { "display": "inline-block" },
+						curCSS, [ elem, "marginRight" ] );
+				}
+			}
+		};
+	}
+
+	// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
+	// getComputedStyle returns percent when specified for top/left/bottom/right
+	// rather than make the css module depend on the offset module, we just check for it here
+	if ( !jQuery.support.pixelPosition && jQuery.fn.position ) {
+		jQuery.each( [ "top", "left" ], function( i, prop ) {
+			jQuery.cssHooks[ prop ] = {
+				get: 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;
+					}
+				}
+			};
+		});
+	}
+
+});
+
+if ( jQuery.expr && jQuery.expr.filters ) {
+	jQuery.expr.filters.hidden = function( elem ) {
+		// Support: Opera <= 12.12
+		// Opera reports offsetWidths and offsetHeights less than zero on some elements
+		return elem.offsetWidth <= 0 && elem.offsetHeight <= 0 ||
+			(!jQuery.support.reliableHiddenOffsets && ((elem.style && elem.style.display) || jQuery.css( elem, "display" )) === "none");
+	};
+
+	jQuery.expr.filters.visible = function( elem ) {
+		return !jQuery.expr.filters.hidden( elem );
+	};
+}
+
+// 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 ( !rmargin.test( prefix ) ) {
+		jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
+	}
+});
+var r20 = /%20/g,
+	rbracket = /\[\]$/,
+	rCRLF = /\r?\n/g,
+	rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,
+	rsubmittable = /^(?:input|select|textarea|keygen)/i;
+
+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 || !manipulation_rcheckableType.test( type ) );
+		})
+		.map(function( i, elem ){
+			var val = jQuery( this ).val();
+
+			return val == null ?
+				null :
+				jQuery.isArray( val ) ?
+					jQuery.map( val, function( val ){
+						return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
+					}) :
+					{ name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
+		}).get();
+	}
+});
+
+//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, value ) {
+			// If value is a function, invoke it and return its value
+			value = jQuery.isFunction( value ) ? value() : ( value == null ? "" : value );
+			s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value );
+		};
+
+	// Set traditional to true for jQuery <= 1.3.2 behavior.
+	if ( traditional === undefined ) {
+		traditional = jQuery.ajaxSettings && jQuery.ajaxSettings.traditional;
+	}
+
+	// If an array was passed in, assume that it is an array of form elements.
+	if ( jQuery.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( "&" ).replace( r20, "+" );
+};
+
+function buildParams( prefix, obj, traditional, add ) {
+	var name;
+
+	if ( jQuery.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" ? i : "" ) + "]", v, traditional, add );
+			}
+		});
+
+	} else if ( !traditional && jQuery.type( obj ) === "object" ) {
+		// Serialize object item.
+		for ( name in obj ) {
+			buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
+		}
+
+	} else {
+		// Serialize scalar item.
+		add( prefix, obj );
+	}
+}
+jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
+	"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
+	"change select submit keydown keypress keyup error 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 );
+	};
+});
+
+jQuery.fn.hover = function( fnOver, fnOut ) {
+	return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
+};
+var
+	// Document location
+	ajaxLocParts,
+	ajaxLocation,
+	ajax_nonce = jQuery.now(),
+
+	ajax_rquery = /\?/,
+	rhash = /#.*$/,
+	rts = /([?&])_=[^&]*/,
+	rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, // IE leaves an \r character at EOL
+	// #7653, #8125, #8152: local protocol detection
+	rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
+	rnoContent = /^(?:GET|HEAD)$/,
+	rprotocol = /^\/\//,
+	rurl = /^([\w.+-]+:)(?:\/\/([^\/?#:]*)(?::(\d+)|)|)/,
+
+	// Keep a copy of the old load method
+	_load = jQuery.fn.load,
+
+	/* 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 (#10098); must appease lint and evade compression
+	allTypes = "*/".concat("*");
+
+// #8138, IE may throw an exception when accessing
+// a field from window.location if document.domain has been set
+try {
+	ajaxLocation = location.href;
+} catch( e ) {
+	// Use the href attribute of an A element
+	// since IE will modify it given document.location
+	ajaxLocation = document.createElement( "a" );
+	ajaxLocation.href = "";
+	ajaxLocation = ajaxLocation.href;
+}
+
+// Segment location into parts
+ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) || [];
+
+// 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( core_rnotwhite ) || [];
+
+		if ( jQuery.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 #9887
+function ajaxExtend( target, src ) {
+	var deep, key,
+		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;
+}
+
+jQuery.fn.load = function( url, params, callback ) {
+	if ( typeof url !== "string" && _load ) {
+		return _load.apply( this, arguments );
+	}
+
+	var selector, response, type,
+		self = this,
+		off = url.indexOf(" ");
+
+	if ( off >= 0 ) {
+		selector = url.slice( off, url.length );
+		url = url.slice( 0, off );
+	}
+
+	// If it's a function
+	if ( jQuery.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
+			type: type,
+			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 );
+
+		}).complete( callback && function( jqXHR, status ) {
+			self.each( callback, response || [ jqXHR.responseText, status, jqXHR ] );
+		});
+	}
+
+	return this;
+};
+
+// Attach a bunch of functions for handling common AJAX events
+jQuery.each( [ "ajaxStart", "ajaxStop", "ajaxComplete", "ajaxError", "ajaxSuccess", "ajaxSend" ], function( i, type ){
+	jQuery.fn[ type ] = function( fn ){
+		return this.on( type, fn );
+	};
+});
+
+jQuery.each( [ "get", "post" ], function( i, method ) {
+	jQuery[ method ] = function( url, data, callback, type ) {
+		// shift arguments if data argument was omitted
+		if ( jQuery.isFunction( data ) ) {
+			type = type || callback;
+			callback = data;
+			data = undefined;
+		}
+
+		return jQuery.ajax({
+			url: url,
+			type: method,
+			dataType: type,
+			data: data,
+			success: callback
+		});
+	};
+});
+
+jQuery.extend({
+
+	// Counter for holding the number of active queries
+	active: 0,
+
+	// Last-Modified header cache for next request
+	lastModified: {},
+	etag: {},
+
+	ajaxSettings: {
+		url: ajaxLocation,
+		type: "GET",
+		isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ),
+		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: /xml/,
+			html: /html/,
+			json: /json/
+		},
+
+		responseFields: {
+			xml: "responseXML",
+			text: "responseText"
+		},
+
+		// Data converters
+		// Keys separate source (or catchall "*") and destination types with a single space
+		converters: {
+
+			// Convert anything to text
+			"* text": window.String,
+
+			// Text to html (true = no transformation)
+			"text html": true,
+
+			// Evaluate text as a json expression
+			"text json": jQuery.parseJSON,
+
+			// 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 // Cross-domain detection vars
+			parts,
+			// Loop variable
+			i,
+			// URL without anti-cache param
+			cacheURL,
+			// Response headers as string
+			responseHeadersString,
+			// timeout handle
+			timeoutTimer,
+
+			// To know if global events are to be dispatched
+			fireGlobals,
+
+			transport,
+			// Response headers
+			responseHeaders,
+			// 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 = {},
+			// The jqXHR state
+			state = 0,
+			// Default abort message
+			strAbort = "canceled",
+			// Fake xhr
+			jqXHR = {
+				readyState: 0,
+
+				// Builds headers hashtable if needed
+				getResponseHeader: function( key ) {
+					var match;
+					if ( state === 2 ) {
+						if ( !responseHeaders ) {
+							responseHeaders = {};
+							while ( (match = rheaders.exec( responseHeadersString )) ) {
+								responseHeaders[ match[1].toLowerCase() ] = match[ 2 ];
+							}
+						}
+						match = responseHeaders[ key.toLowerCase() ];
+					}
+					return match == null ? null : match;
+				},
+
+				// Raw string
+				getAllResponseHeaders: function() {
+					return state === 2 ? responseHeadersString : null;
+				},
+
+				// Caches the header
+				setRequestHeader: function( name, value ) {
+					var lname = name.toLowerCase();
+					if ( !state ) {
+						name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name;
+						requestHeaders[ name ] = value;
+					}
+					return this;
+				},
+
+				// Overrides response content-type header
+				overrideMimeType: function( type ) {
+					if ( !state ) {
+						s.mimeType = type;
+					}
+					return this;
+				},
+
+				// Status-dependent callbacks
+				statusCode: function( map ) {
+					var code;
+					if ( map ) {
+						if ( state < 2 ) {
+							for ( code in map ) {
+								// Lazy-add the new callback in a way that preserves old ones
+								statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
+							}
+						} else {
+							// Execute the appropriate callbacks
+							jqXHR.always( map[ jqXHR.status ] );
+						}
+					}
+					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 ).complete = completeDeferred.add;
+		jqXHR.success = jqXHR.done;
+		jqXHR.error = jqXHR.fail;
+
+		// Remove hash character (#7531: and string promotion)
+		// Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
+		// Handle falsy url in the settings object (#10093: consistency with old signature)
+		// We also use the url parameter if available
+		s.url = ( ( url || s.url || ajaxLocation ) + "" ).replace( rhash, "" ).replace( rprotocol, ajaxLocParts[ 1 ] + "//" );
+
+		// Alias method option to type as per ticket #12004
+		s.type = options.method || options.type || s.method || s.type;
+
+		// Extract dataTypes list
+		s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().match( core_rnotwhite ) || [""];
+
+		// A cross-domain request is in order when we have a protocol:host:port mismatch
+		if ( s.crossDomain == null ) {
+			parts = rurl.exec( s.url.toLowerCase() );
+			s.crossDomain = !!( parts &&
+				( parts[ 1 ] !== ajaxLocParts[ 1 ] || parts[ 2 ] !== ajaxLocParts[ 2 ] ||
+					( parts[ 3 ] || ( parts[ 1 ] === "http:" ? 80 : 443 ) ) !=
+						( ajaxLocParts[ 3 ] || ( ajaxLocParts[ 1 ] === "http:" ? 80 : 443 ) ) )
+			);
+		}
+
+		// 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 ( state === 2 ) {
+			return jqXHR;
+		}
+
+		// We can fire global events as of now if asked to
+		fireGlobals = 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
+		cacheURL = s.url;
+
+		// More options handling for requests with no content
+		if ( !s.hasContent ) {
+
+			// If data is available, append data to url
+			if ( s.data ) {
+				cacheURL = ( s.url += ( ajax_rquery.test( cacheURL ) ? "&" : "?" ) + s.data );
+				// #9682: remove data so that it's not used in an eventual retry
+				delete s.data;
+			}
+
+			// Add anti-cache in url if needed
+			if ( s.cache === false ) {
+				s.url = rts.test( cacheURL ) ?
+
+					// If there is already a '_' parameter, set its value
+					cacheURL.replace( rts, "$1_=" + ajax_nonce++ ) :
+
+					// Otherwise add one to the end
+					cacheURL + ( ajax_rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ajax_nonce++;
+			}
+		}
+
+		// 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 || state === 2 ) ) {
+			// Abort if not done already and return
+			return jqXHR.abort();
+		}
+
+		// aborting is no longer a cancellation
+		strAbort = "abort";
+
+		// Install callbacks on deferreds
+		for ( i in { success: 1, error: 1, complete: 1 } ) {
+			jqXHR[ i ]( s[ i ] );
+		}
+
+		// 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 ] );
+			}
+			// Timeout
+			if ( s.async && s.timeout > 0 ) {
+				timeoutTimer = setTimeout(function() {
+					jqXHR.abort("timeout");
+				}, s.timeout );
+			}
+
+			try {
+				state = 1;
+				transport.send( requestHeaders, done );
+			} catch ( e ) {
+				// Propagate exception as error if not done
+				if ( state < 2 ) {
+					done( -1, e );
+				// Simply rethrow otherwise
+				} else {
+					throw e;
+				}
+			}
+		}
+
+		// Callback for when everything is done
+		function done( status, nativeStatusText, responses, headers ) {
+			var isSuccess, success, error, response, modified,
+				statusText = nativeStatusText;
+
+			// Called once
+			if ( state === 2 ) {
+				return;
+			}
+
+			// State is "done" now
+			state = 2;
+
+			// Clear timeout if it exists
+			if ( timeoutTimer ) {
+				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;
+
+			// Get response data
+			if ( responses ) {
+				response = ajaxHandleResponses( s, jqXHR, responses );
+			}
+
+			// If successful, handle type chaining
+			if ( status >= 200 && status < 300 || status === 304 ) {
+
+				// 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 ) {
+					isSuccess = true;
+					statusText = "nocontent";
+
+				// if not modified
+				} else if ( status === 304 ) {
+					isSuccess = true;
+					statusText = "notmodified";
+
+				// If we have data, let's convert it
+				} else {
+					isSuccess = ajaxConvert( s, response );
+					statusText = isSuccess.state;
+					success = isSuccess.data;
+					error = isSuccess.error;
+					isSuccess = !error;
+				}
+			} else {
+				// We extract error from statusText
+				// then normalize statusText and status 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;
+	},
+
+	getScript: function( url, callback ) {
+		return jQuery.get( url, undefined, callback, "script" );
+	},
+
+	getJSON: function( url, data, callback ) {
+		return jQuery.get( url, data, callback, "json" );
+	}
+});
+
+/* Handles responses to an ajax request:
+ * - sets all responseXXX fields accordingly
+ * - finds the right dataType (mediates between content-type and expected dataType)
+ * - returns the corresponding response
+ */
+function ajaxHandleResponses( s, jqXHR, responses ) {
+	var firstDataType, ct, finalDataType, type,
+		contents = s.contents,
+		dataTypes = s.dataTypes,
+		responseFields = s.responseFields;
+
+	// Fill responseXXX fields
+	for ( type in responseFields ) {
+		if ( type in responses ) {
+			jqXHR[ responseFields[type] ] = responses[ type ];
+		}
+	}
+
+	// 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
+function ajaxConvert( s, response ) {
+	var conv2, current, conv, tmp,
+		converters = {},
+		i = 0,
+		// Work with a copy of dataTypes in case we need to modify it for conversion
+		dataTypes = s.dataTypes.slice(),
+		prev = dataTypes[ 0 ];
+
+	// Apply the dataFilter if provided
+	if ( s.dataFilter ) {
+		response = s.dataFilter( response, s.dataType );
+	}
+
+	// Create converters map with lowercased keys
+	if ( dataTypes[ 1 ] ) {
+		for ( conv in s.converters ) {
+			converters[ conv.toLowerCase() ] = s.converters[ conv ];
+		}
+	}
+
+	// Convert to each sequential dataType, tolerating list modification
+	for ( ; (current = dataTypes[++i]); ) {
+
+		// There's only work to do if current dataType is non-auto
+		if ( current !== "*" ) {
+
+			// Convert response if prev dataType is non-auto and differs from current
+			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.splice( i--, 0, current );
+								}
+
+								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 };
+						}
+					}
+				}
+			}
+
+			// Update prev for next iteration
+			prev = current;
+		}
+	}
+
+	return { state: "success", data: response };
+}
+// Install script dataType
+jQuery.ajaxSetup({
+	accepts: {
+		script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
+	},
+	contents: {
+		script: /(?:java|ecma)script/
+	},
+	converters: {
+		"text script": function( text ) {
+			jQuery.globalEval( text );
+			return text;
+		}
+	}
+});
+
+// Handle cache's special case and global
+jQuery.ajaxPrefilter( "script", function( s ) {
+	if ( s.cache === undefined ) {
+		s.cache = false;
+	}
+	if ( s.crossDomain ) {
+		s.type = "GET";
+		s.global = false;
+	}
+});
+
+// Bind script tag hack transport
+jQuery.ajaxTransport( "script", function(s) {
+
+	// This transport only deals with cross domain requests
+	if ( s.crossDomain ) {
+
+		var script,
+			head = document.head || jQuery("head")[0] || document.documentElement;
+
+		return {
+
+			send: function( _, callback ) {
+
+				script = document.createElement("script");
+
+				script.async = true;
+
+				if ( s.scriptCharset ) {
+					script.charset = s.scriptCharset;
+				}
+
+				script.src = s.url;
+
+				// Attach handlers for all browsers
+				script.onload = script.onreadystatechange = function( _, isAbort ) {
+
+					if ( isAbort || !script.readyState || /loaded|complete/.test( script.readyState ) ) {
+
+						// Handle memory leak in IE
+						script.onload = script.onreadystatechange = null;
+
+						// Remove the script
+						if ( script.parentNode ) {
+							script.parentNode.removeChild( script );
+						}
+
+						// Dereference the script
+						script = null;
+
+						// Callback if not abort
+						if ( !isAbort ) {
+							callback( 200, "success" );
+						}
+					}
+				};
+
+				// Circumvent IE6 bugs with base elements (#2709 and #4378) by prepending
+				// Use native DOM manipulation to avoid our domManip AJAX trickery
+				head.insertBefore( script, head.firstChild );
+			},
+
+			abort: function() {
+				if ( script ) {
+					script.onload( undefined, true );
+				}
+			}
+		};
+	}
+});
+var oldCallbacks = [],
+	rjsonp = /(=)\?(?=&|$)|\?\?/;
+
+// Default jsonp settings
+jQuery.ajaxSetup({
+	jsonp: "callback",
+	jsonpCallback: function() {
+		var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( ajax_nonce++ ) );
+		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") && 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 = jQuery.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 += ( ajax_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() {
+			// Restore preexisting value
+			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 && jQuery.isFunction( overwritten ) ) {
+				overwritten( responseContainer[ 0 ] );
+			}
+
+			responseContainer = overwritten = undefined;
+		});
+
+		// Delegate to script
+		return "script";
+	}
+});
+var xhrCallbacks, xhrSupported,
+	xhrId = 0,
+	// #5280: Internet Explorer will keep connections alive if we don't abort on unload
+	xhrOnUnloadAbort = window.ActiveXObject && function() {
+		// Abort all pending requests
+		var key;
+		for ( key in xhrCallbacks ) {
+			xhrCallbacks[ key ]( undefined, true );
+		}
+	};
+
+// Functions to create xhrs
+function createStandardXHR() {
+	try {
+		return new window.XMLHttpRequest();
+	} catch( e ) {}
+}
+
+function createActiveXHR() {
+	try {
+		return new window.ActiveXObject("Microsoft.XMLHTTP");
+	} catch( e ) {}
+}
+
+// Create the request object
+// (This is still attached to ajaxSettings for backward compatibility)
+jQuery.ajaxSettings.xhr = window.ActiveXObject ?
+	/* Microsoft failed to properly
+	 * implement the XMLHttpRequest in IE7 (can't request local files),
+	 * so we use the ActiveXObject when it is available
+	 * Additionally XMLHttpRequest can be disabled in IE7/IE8 so
+	 * we need a fallback.
+	 */
+	function() {
+		return !this.isLocal && createStandardXHR() || createActiveXHR();
+	} :
+	// For all other browsers, use the standard XMLHttpRequest object
+	createStandardXHR;
+
+// Determine support properties
+xhrSupported = jQuery.ajaxSettings.xhr();
+jQuery.support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported );
+xhrSupported = jQuery.support.ajax = !!xhrSupported;
+
+// Create transport if the browser can provide an xhr
+if ( xhrSupported ) {
+
+	jQuery.ajaxTransport(function( s ) {
+		// Cross domain only allowed if supported through XMLHttpRequest
+		if ( !s.crossDomain || jQuery.support.cors ) {
+
+			var callback;
+
+			return {
+				send: function( headers, complete ) {
+
+					// Get a new xhr
+					var handle, i,
+						xhr = s.xhr();
+
+					// Open the socket
+					// Passing null username, generates a login popup on Opera (#2865)
+					if ( s.username ) {
+						xhr.open( s.type, s.url, s.async, s.username, s.password );
+					} else {
+						xhr.open( s.type, s.url, s.async );
+					}
+
+					// Apply custom fields if provided
+					if ( s.xhrFields ) {
+						for ( i in s.xhrFields ) {
+							xhr[ i ] = s.xhrFields[ i ];
+						}
+					}
+
+					// Override mime type if needed
+					if ( s.mimeType && xhr.overrideMimeType ) {
+						xhr.overrideMimeType( s.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 ( !s.crossDomain && !headers["X-Requested-With"] ) {
+						headers["X-Requested-With"] = "XMLHttpRequest";
+					}
+
+					// Need an extra try/catch for cross domain requests in Firefox 3
+					try {
+						for ( i in headers ) {
+							xhr.setRequestHeader( i, headers[ i ] );
+						}
+					} catch( err ) {}
+
+					// Do send the request
+					// This may raise an exception which is actually
+					// handled in jQuery.ajax (so no try/catch here)
+					xhr.send( ( s.hasContent && s.data ) || null );
+
+					// Listener
+					callback = function( _, isAbort ) {
+						var status, responseHeaders, statusText, responses;
+
+						// Firefox throws exceptions when accessing properties
+						// of an xhr when a network error occurred
+						// http://helpful.knobs-dials.com/index.php/Component_returned_failure_code:_0x80040111_(NS_ERROR_NOT_AVAILABLE)
+						try {
+
+							// Was never called and is aborted or complete
+							if ( callback && ( isAbort || xhr.readyState === 4 ) ) {
+
+								// Only called once
+								callback = undefined;
+
+								// Do not keep as active anymore
+								if ( handle ) {
+									xhr.onreadystatechange = jQuery.noop;
+									if ( xhrOnUnloadAbort ) {
+										delete xhrCallbacks[ handle ];
+									}
+								}
+
+								// If it's an abort
+								if ( isAbort ) {
+									// Abort it manually if needed
+									if ( xhr.readyState !== 4 ) {
+										xhr.abort();
+									}
+								} else {
+									responses = {};
+									status = xhr.status;
+									responseHeaders = xhr.getAllResponseHeaders();
+
+									// When requesting binary data, IE6-9 will throw an exception
+									// on any attempt to access responseText (#11426)
+									if ( typeof xhr.responseText === "string" ) {
+										responses.text = xhr.responseText;
+									}
+
+									// Firefox throws an exception when accessing
+									// statusText for faulty cross-domain requests
+									try {
+										statusText = xhr.statusText;
+									} catch( e ) {
+										// We normalize with Webkit giving an empty statusText
+										statusText = "";
+									}
+
+									// Filter status for non standard behaviors
+
+									// If the request is local and we have data: assume a success
+									// (success with no data won't get notified, that's the best we
+									// can do given current implementations)
+									if ( !status && s.isLocal && !s.crossDomain ) {
+										status = responses.text ? 200 : 404;
+									// IE - #1450: sometimes returns 1223 when it should be 204
+									} else if ( status === 1223 ) {
+										status = 204;
+									}
+								}
+							}
+						} catch( firefoxAccessException ) {
+							if ( !isAbort ) {
+								complete( -1, firefoxAccessException );
+							}
+						}
+
+						// Call complete if needed
+						if ( responses ) {
+							complete( status, statusText, responses, responseHeaders );
+						}
+					};
+
+					if ( !s.async ) {
+						// if we're in sync mode we fire the callback
+						callback();
+					} else if ( xhr.readyState === 4 ) {
+						// (IE6 & IE7) if it's in cache and has been
+						// retrieved directly we need to fire the callback
+						setTimeout( callback );
+					} else {
+						handle = ++xhrId;
+						if ( xhrOnUnloadAbort ) {
+							// Create the active xhrs callbacks list if needed
+							// and attach the unload handler
+							if ( !xhrCallbacks ) {
+								xhrCallbacks = {};
+								jQuery( window ).unload( xhrOnUnloadAbort );
+							}
+							// Add to list of active xhrs callbacks
+							xhrCallbacks[ handle ] = callback;
+						}
+						xhr.onreadystatechange = callback;
+					}
+				},
+
+				abort: function() {
+					if ( callback ) {
+						callback( undefined, true );
+					}
+				}
+			};
+		}
+	});
+}
+var fxNow, timerId,
+	rfxtypes = /^(?:toggle|show|hide)$/,
+	rfxnum = new RegExp( "^(?:([+-])=|)(" + core_pnum + ")([a-z%]*)$", "i" ),
+	rrun = /queueHooks$/,
+	animationPrefilters = [ defaultPrefilter ],
+	tweeners = {
+		"*": [function( prop, value ) {
+			var end, unit,
+				tween = this.createTween( prop, value ),
+				parts = rfxnum.exec( value ),
+				target = tween.cur(),
+				start = +target || 0,
+				scale = 1,
+				maxIterations = 20;
+
+			if ( parts ) {
+				end = +parts[2];
+				unit = parts[3] || ( jQuery.cssNumber[ prop ] ? "" : "px" );
+
+				// We need to compute starting value
+				if ( unit !== "px" && start ) {
+					// Iteratively approximate from a nonzero starting point
+					// Prefer the current property, because this process will be trivial if it uses the same units
+					// Fallback to end or a simple constant
+					start = jQuery.css( tween.elem, prop, true ) || end || 1;
+
+					do {
+						// If previous iteration zeroed out, double until we get *something*
+						// Use a string for doubling factor so we don't accidentally see scale as unchanged below
+						scale = scale || ".5";
+
+						// Adjust and apply
+						start = start / scale;
+						jQuery.style( tween.elem, prop, start + unit );
+
+					// Update scale, tolerating zero or NaN from tween.cur()
+					// And breaking the loop if scale is unchanged or perfect, or if we've just had enough
+					} while ( scale !== (scale = tween.cur() / target) && scale !== 1 && --maxIterations );
+				}
+
+				tween.unit = unit;
+				tween.start = start;
+				// If a +=/-= token was provided, we're doing a relative animation
+				tween.end = parts[1] ? start + ( parts[1] + 1 ) * end : end;
+			}
+			return tween;
+		}]
+	};
+
+// Animations created synchronously will run synchronously
+function createFxNow() {
+	setTimeout(function() {
+		fxNow = undefined;
+	});
+	return ( fxNow = jQuery.now() );
+}
+
+function createTweens( animation, props ) {
+	jQuery.each( props, function( prop, value ) {
+		var collection = ( tweeners[ prop ] || [] ).concat( tweeners[ "*" ] ),
+			index = 0,
+			length = collection.length;
+		for ( ; index < length; index++ ) {
+			if ( collection[ index ].call( animation, prop, value ) ) {
+
+				// we're done with this property
+				return;
+			}
+		}
+	});
+}
+
+function Animation( elem, properties, options ) {
+	var result,
+		stopped,
+		index = 0,
+		length = animationPrefilters.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 ),
+				// archaic crash bug won't allow us to use 1 - ( 0.5 || 0 ) (#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 ( percent < 1 && length ) {
+				return remaining;
+			} else {
+				deferred.resolveWith( elem, [ animation ] );
+				return false;
+			}
+		},
+		animation = deferred.promise({
+			elem: elem,
+			props: jQuery.extend( {}, properties ),
+			opts: jQuery.extend( true, { specialEasing: {} }, 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.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 = animationPrefilters[ index ].call( animation, elem, props, animation.opts );
+		if ( result ) {
+			return result;
+		}
+	}
+
+	createTweens( animation, props );
+
+	if ( jQuery.isFunction( animation.opts.start ) ) {
+		animation.opts.start.call( elem, animation );
+	}
+
+	jQuery.fx.timer(
+		jQuery.extend( tick, {
+			elem: elem,
+			anim: animation,
+			queue: animation.opts.queue
+		})
+	);
+
+	// attach callbacks from options
+	return animation.progress( animation.opts.progress )
+		.done( animation.opts.done, animation.opts.complete )
+		.fail( animation.opts.fail )
+		.always( animation.opts.always );
+}
+
+function propFilter( props, specialEasing ) {
+	var value, name, index, easing, hooks;
+
+	// camelCase, specialEasing and expand cssHook pass
+	for ( index in props ) {
+		name = jQuery.camelCase( index );
+		easing = specialEasing[ name ];
+		value = props[ index ];
+		if ( jQuery.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 wont overwrite keys already present.
+			// also - reusing 'index' from above 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;
+		}
+	}
+}
+
+jQuery.Animation = jQuery.extend( Animation, {
+
+	tweener: function( props, callback ) {
+		if ( jQuery.isFunction( props ) ) {
+			callback = props;
+			props = [ "*" ];
+		} else {
+			props = props.split(" ");
+		}
+
+		var prop,
+			index = 0,
+			length = props.length;
+
+		for ( ; index < length ; index++ ) {
+			prop = props[ index ];
+			tweeners[ prop ] = tweeners[ prop ] || [];
+			tweeners[ prop ].unshift( callback );
+		}
+	},
+
+	prefilter: function( callback, prepend ) {
+		if ( prepend ) {
+			animationPrefilters.unshift( callback );
+		} else {
+			animationPrefilters.push( callback );
+		}
+	}
+});
+
+function defaultPrefilter( elem, props, opts ) {
+	/*jshint validthis:true */
+	var prop, index, length,
+		value, dataShow, toggle,
+		tween, hooks, oldfire,
+		anim = this,
+		style = elem.style,
+		orig = {},
+		handled = [],
+		hidden = elem.nodeType && isHidden( elem );
+
+	// handle queue: false promises
+	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() {
+			// doing this makes sure that the complete handler will be called
+			// before this completes
+			anim.always(function() {
+				hooks.unqueued--;
+				if ( !jQuery.queue( elem, "fx" ).length ) {
+					hooks.empty.fire();
+				}
+			});
+		});
+	}
+
+	// height/width overflow pass
+	if ( elem.nodeType === 1 && ( "height" in props || "width" in props ) ) {
+		// Make sure that nothing sneaks out
+		// Record all 3 overflow attributes because IE does not
+		// change the overflow attribute when overflowX and
+		// overflowY are set to the same value
+		opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];
+
+		// Set display property to inline-block for height/width
+		// animations on inline elements that are having width/height animated
+		if ( jQuery.css( elem, "display" ) === "inline" &&
+				jQuery.css( elem, "float" ) === "none" ) {
+
+			// inline-level elements accept inline-block;
+			// block-level elements need to be inline with layout
+			if ( !jQuery.support.inlineBlockNeedsLayout || css_defaultDisplay( elem.nodeName ) === "inline" ) {
+				style.display = "inline-block";
+
+			} else {
+				style.zoom = 1;
+			}
+		}
+	}
+
+	if ( opts.overflow ) {
+		style.overflow = "hidden";
+		if ( !jQuery.support.shrinkWrapBlocks ) {
+			anim.always(function() {
+				style.overflow = opts.overflow[ 0 ];
+				style.overflowX = opts.overflow[ 1 ];
+				style.overflowY = opts.overflow[ 2 ];
+			});
+		}
+	}
+
+
+	// show/hide pass
+	for ( index in props ) {
+		value = props[ index ];
+		if ( rfxtypes.exec( value ) ) {
+			delete props[ index ];
+			toggle = toggle || value === "toggle";
+			if ( value === ( hidden ? "hide" : "show" ) ) {
+				continue;
+			}
+			handled.push( index );
+		}
+	}
+
+	length = handled.length;
+	if ( length ) {
+		dataShow = jQuery._data( elem, "fxshow" ) || jQuery._data( elem, "fxshow", {} );
+		if ( "hidden" in dataShow ) {
+			hidden = dataShow.hidden;
+		}
+
+		// store state if its toggle - enables .stop().toggle() to "reverse"
+		if ( toggle ) {
+			dataShow.hidden = !hidden;
+		}
+		if ( hidden ) {
+			jQuery( elem ).show();
+		} else {
+			anim.done(function() {
+				jQuery( elem ).hide();
+			});
+		}
+		anim.done(function() {
+			var prop;
+			jQuery._removeData( elem, "fxshow" );
+			for ( prop in orig ) {
+				jQuery.style( elem, prop, orig[ prop ] );
+			}
+		});
+		for ( index = 0 ; index < length ; index++ ) {
+			prop = handled[ index ];
+			tween = anim.createTween( prop, hidden ? dataShow[ prop ] : 0 );
+			orig[ prop ] = dataShow[ prop ] || jQuery.style( elem, prop );
+
+			if ( !( prop in dataShow ) ) {
+				dataShow[ prop ] = tween.start;
+				if ( hidden ) {
+					tween.end = tween.start;
+					tween.start = prop === "width" || prop === "height" ? 1 : 0;
+				}
+			}
+		}
+	}
+}
+
+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 || "swing";
+		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;
+
+			if ( tween.elem[ tween.prop ] != null &&
+				(!tween.elem.style || 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
+			// so, 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 its
+			// available and use plain properties where available
+			if ( jQuery.fx.step[ tween.prop ] ) {
+				jQuery.fx.step[ tween.prop ]( tween );
+			} else if ( tween.elem.style && ( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null || jQuery.cssHooks[ tween.prop ] ) ) {
+				jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );
+			} else {
+				tween.elem[ tween.prop ] = tween.now;
+			}
+		}
+	}
+};
+
+// Remove in 2.0 - this supports IE8's 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.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 );
+	};
+});
+
+jQuery.fn.extend({
+	fadeTo: function( speed, to, easing, callback ) {
+
+		// show any hidden elements after setting opacity to 0
+		return this.filter( isHidden ).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 );
+				doAnimation.finish = function() {
+					anim.stop( true );
+				};
+				// Empty animations, or finishing resolves immediately
+				if ( empty || jQuery._data( 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 && type !== false ) {
+			this.queue( type || "fx", [] );
+		}
+
+		return this.each(function() {
+			var dequeue = true,
+				index = type != null && type + "queueHooks",
+				timers = jQuery.timers,
+				data = jQuery._data( 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 = jQuery._data( 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.cur && hooks.cur.finish ) {
+				hooks.cur.finish.call( this );
+			}
+
+			// 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;
+		});
+	}
+});
+
+// Generate parameters to create a standard animation
+function genFx( type, includeWidth ) {
+	var which,
+		attrs = { height: type },
+		i = 0;
+
+	// if we include width, step value is 1 to do all cssExpand values,
+	// if we don't include width, 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;
+}
+
+// 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.speed = function( speed, easing, fn ) {
+	var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
+		complete: fn || !fn && easing ||
+			jQuery.isFunction( speed ) && speed,
+		duration: speed,
+		easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing
+	};
+
+	opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
+		opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[ 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 ( jQuery.isFunction( opt.old ) ) {
+			opt.old.call( this );
+		}
+
+		if ( opt.queue ) {
+			jQuery.dequeue( this, opt.queue );
+		}
+	};
+
+	return opt;
+};
+
+jQuery.easing = {
+	linear: function( p ) {
+		return p;
+	},
+	swing: function( p ) {
+		return 0.5 - Math.cos( p*Math.PI ) / 2;
+	}
+};
+
+jQuery.timers = [];
+jQuery.fx = Tween.prototype.init;
+jQuery.fx.tick = function() {
+	var timer,
+		timers = jQuery.timers,
+		i = 0;
+
+	fxNow = jQuery.now();
+
+	for ( ; i < timers.length; i++ ) {
+		timer = timers[ i ];
+		// Checks the timer has not already been removed
+		if ( !timer() && timers[ i ] === timer ) {
+			timers.splice( i--, 1 );
+		}
+	}
+
+	if ( !timers.length ) {
+		jQuery.fx.stop();
+	}
+	fxNow = undefined;
+};
+
+jQuery.fx.timer = function( timer ) {
+	if ( timer() && jQuery.timers.push( timer ) ) {
+		jQuery.fx.start();
+	}
+};
+
+jQuery.fx.interval = 13;
+
+jQuery.fx.start = function() {
+	if ( !timerId ) {
+		timerId = setInterval( jQuery.fx.tick, jQuery.fx.interval );
+	}
+};
+
+jQuery.fx.stop = function() {
+	clearInterval( timerId );
+	timerId = null;
+};
+
+jQuery.fx.speeds = {
+	slow: 600,
+	fast: 200,
+	// Default speed
+	_default: 400
+};
+
+// Back Compat <1.8 extension point
+jQuery.fx.step = {};
+
+if ( jQuery.expr && jQuery.expr.filters ) {
+	jQuery.expr.filters.animated = function( elem ) {
+		return jQuery.grep(jQuery.timers, function( fn ) {
+			return elem === fn.elem;
+		}).length;
+	};
+}
+jQuery.fn.offset = function( options ) {
+	if ( arguments.length ) {
+		return options === undefined ?
+			this :
+			this.each(function( i ) {
+				jQuery.offset.setOffset( this, options, i );
+			});
+	}
+
+	var docElem, win,
+		box = { top: 0, left: 0 },
+		elem = this[ 0 ],
+		doc = elem && elem.ownerDocument;
+
+	if ( !doc ) {
+		return;
+	}
+
+	docElem = doc.documentElement;
+
+	// Make sure it's not a disconnected DOM node
+	if ( !jQuery.contains( docElem, elem ) ) {
+		return box;
+	}
+
+	// If we don't have gBCR, just use 0,0 rather than error
+	// BlackBerry 5, iOS 3 (original iPhone)
+	if ( typeof elem.getBoundingClientRect !== core_strundefined ) {
+		box = elem.getBoundingClientRect();
+	}
+	win = getWindow( doc );
+	return {
+		top: box.top  + ( win.pageYOffset || docElem.scrollTop )  - ( docElem.clientTop  || 0 ),
+		left: box.left + ( win.pageXOffset || docElem.scrollLeft ) - ( docElem.clientLeft || 0 )
+	};
+};
+
+jQuery.offset = {
+
+	setOffset: function( elem, options, i ) {
+		var position = jQuery.css( elem, "position" );
+
+		// set position first, in-case top/left are set even on static elem
+		if ( position === "static" ) {
+			elem.style.position = "relative";
+		}
+
+		var curElem = jQuery( elem ),
+			curOffset = curElem.offset(),
+			curCSSTop = jQuery.css( elem, "top" ),
+			curCSSLeft = jQuery.css( elem, "left" ),
+			calculatePosition = ( position === "absolute" || position === "fixed" ) && jQuery.inArray("auto", [curCSSTop, curCSSLeft]) > -1,
+			props = {}, curPosition = {}, curTop, curLeft;
+
+		// 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 ( jQuery.isFunction( options ) ) {
+			options = options.call( elem, i, 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({
+
+	position: function() {
+		if ( !this[ 0 ] ) {
+			return;
+		}
+
+		var offsetParent, offset,
+			parentOffset = { top: 0, left: 0 },
+			elem = this[ 0 ];
+
+		// fixed elements are offset from window (parentOffset = {top:0, left: 0}, because it is it's only offset parent
+		if ( jQuery.css( elem, "position" ) === "fixed" ) {
+			// we assume that getBoundingClientRect is available when computed position is fixed
+			offset = elem.getBoundingClientRect();
+		} else {
+			// Get *real* offsetParent
+			offsetParent = this.offsetParent();
+
+			// Get correct offsets
+			offset = this.offset();
+			if ( !jQuery.nodeName( offsetParent[ 0 ], "html" ) ) {
+				parentOffset = offsetParent.offset();
+			}
+
+			// Add offsetParent borders
+			parentOffset.top  += jQuery.css( offsetParent[ 0 ], "borderTopWidth", true );
+			parentOffset.left += jQuery.css( offsetParent[ 0 ], "borderLeftWidth", true );
+		}
+
+		// Subtract parent offsets and element margins
+		// note: when an element has margin: auto the offsetLeft and marginLeft
+		// are the same in Safari causing offset.left to incorrectly be 0
+		return {
+			top:  offset.top  - parentOffset.top - jQuery.css( elem, "marginTop", true ),
+			left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true)
+		};
+	},
+
+	offsetParent: function() {
+		return this.map(function() {
+			var offsetParent = this.offsetParent || document.documentElement;
+			while ( offsetParent && ( !jQuery.nodeName( offsetParent, "html" ) && jQuery.css( offsetParent, "position") === "static" ) ) {
+				offsetParent = offsetParent.offsetParent;
+			}
+			return offsetParent || document.documentElement;
+		});
+	}
+});
+
+
+// Create scrollLeft and scrollTop methods
+jQuery.each( {scrollLeft: "pageXOffset", scrollTop: "pageYOffset"}, function( method, prop ) {
+	var top = /Y/.test( prop );
+
+	jQuery.fn[ method ] = function( val ) {
+		return jQuery.access( this, function( elem, method, val ) {
+			var win = getWindow( elem );
+
+			if ( val === undefined ) {
+				return win ? (prop in win) ? win[ prop ] :
+					win.document.documentElement[ method ] :
+					elem[ method ];
+			}
+
+			if ( win ) {
+				win.scrollTo(
+					!top ? val : jQuery( win ).scrollLeft(),
+					top ? val : jQuery( win ).scrollTop()
+				);
+
+			} else {
+				elem[ method ] = val;
+			}
+		}, method, val, arguments.length, null );
+	};
+});
+
+function getWindow( elem ) {
+	return jQuery.isWindow( elem ) ?
+		elem :
+		elem.nodeType === 9 ?
+			elem.defaultView || elem.parentWindow :
+			false;
+}
+// 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 jQuery.access( this, function( elem, type, value ) {
+				var doc;
+
+				if ( jQuery.isWindow( elem ) ) {
+					// As of 5/8/2012 this will yield incorrect results for Mobile Safari, but there
+					// isn't a whole lot we can do. See pull request at this URL for discussion:
+					// https://github.com/jquery/jquery/pull/764
+					return 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
+					// unfortunately, this causes bug #3838 in IE6/8 only, but there is currently no good, small way to fix it.
+					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, null );
+		};
+	});
+});
+// Limit scope pollution from any deprecated API
+// (function() {
+
+// })();
+// Expose jQuery to the global object
+window.jQuery = window.$ = jQuery;
+
+// Expose jQuery as an AMD module, but only for AMD loaders that
+// understand the issues with loading multiple versions of jQuery
+// in a page that all might call define(). The loader will indicate
+// they have special allowances for multiple jQuery versions by
+// specifying define.amd.jQuery = true. Register as a named module,
+// since jQuery can be concatenated with other files that may use define,
+// but not use 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.
+if ( typeof define === "function" && define.amd && define.amd.jQuery ) {
+	define( "jquery", [], function () { return jQuery; } );
+}
+
+})( window );
diff --git a/module/web/static/js/libs/jquery.animate-enhanced-0.99.js b/module/web/static/js/libs/jquery.animate-enhanced-0.99.js
new file mode 100644
index 000000000..365ca2460
--- /dev/null
+++ b/module/web/static/js/libs/jquery.animate-enhanced-0.99.js
@@ -0,0 +1,812 @@
+/*
+ jquery.animate-enhanced plugin v0.99
+ ---
+ http://github.com/benbarnett/jQuery-Animate-Enhanced
+ http://benbarnett.net
+ @benpbarnett
+ ---
+ Copyright (c) 2012 Ben Barnett
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ ---
+ Extends jQuery.animate() to automatically use CSS3 transformations where applicable.
+ Tested with jQuery 1.3.2+
+
+ Supports -moz-transition, -webkit-transition, -o-transition, transition
+
+ Targetted properties (for now):
+ - left
+ - top
+ - opacity
+ - width
+ - height
+
+ Usage (exactly the same as it would be normally):
+
+ jQuery(element).animate({left: 200},  500, function() {
+ // callback
+ });
+
+ Changelog:
+ 0.99 (5/12/2012):
+ - PR #109 Added support for list-item nodes. FadeIn on tags was omitting the list-style support. (thx @SeanCannon)
+
+ 0.98 (12/11/2012):
+ - Merging pull request #106 thx @gboysko - checking for ownerDocument before using getComputedStyle
+
+ 0.97 (6/11/2012):
+ - Merging pull request #104 thx @gavrochelegnou - .bind instead of .one
+
+ 0.96a (20/08/2012):
+ - Checking event is from dispatch target (issue #58)
+
+ 0.96 (20/08/2012):
+ - Fixes for context, all elements returned as context (issue #84)
+ - Reset position with leaveTransforms !== true fixes (issue #93)
+
+
+ 0.95 (20/08/2012):
+ - If target opacity == current opacity, pass back to jquery native to get callback firing (#94)
+
+ 0.94 (20/08/2012):
+ - Addresses Firefox callback mechanisms (issue #94)
+ - using $.one() to bind to CSS callbacks in a more generic way
+
+ 0.93 (6/8/2012):
+ - Adding other Opera 'transitionend' event (re: issue #90)
+
+ 0.92 (6/8/2012):
+ - Seperate unbinds into different threads (re: issue #91)
+
+ 0.91 (2/4/2012):
+ - Merge Pull Request #74 - Unit Management
+
+ 0.90 (7/3/2012):
+ - Adding public $.toggleDisabledByDefault() feature to disable entire plugin by default (Issue #73)
+
+ 0.89 (24/1/2012):
+ - Adding 'avoidCSSTransitions' property. Set to true to disable entire plugin. (Issue #47)
+
+ 0.88 (24/1/2012):
+ - Fix Issue #67 for HighchartsJS compatibility
+
+ 0.87 (24/1/2012):
+ - Fix Issue #66 selfCSSData.original is undefined
+
+ 0.86 (9/1/2012):
+ - Strict JS fix for undefined variable
+
+ 0.85 (20/12/2011):
+ - Merge Pull request #57 from Kronuz
+ - Codebase cleaned and now passes jshint.
+ - Fixed a few bugs (it now saves and restores the original css transition properties).
+ - fadeOut() is fixed, it wasn't restoring the opacity after hiding it.
+
+ 0.80 (13/09/2011):
+ - Issue #28 - Report $(el).is(':animated') fix
+
+ 0.79 (06/09/2011):
+ - Issue #42 - Right negative position animation: please see issue notes on Github.
+
+ 0.78 (02/09/2011):
+ - Issue #18 - jQuery/$ reference joys
+
+ 0.77 (02/09/2011):
+ - Adding feature on Github issue #44 - Use 3D Transitions by default
+
+ 0.76 (28/06/2011):
+ - Fixing issue #37 - fixed stop() method (with gotoEnd == false)
+
+ 0.75 (15/06/2011):
+ - Fixing issue #35 to pass actual object back as context for callback
+
+ 0.74 (28/05/2011):
+ - Fixing issue #29 to play nice with 1.6+
+
+ 0.73 (05/03/2011):
+ - Merged Pull Request #26: Fixed issue with fadeOut() / "hide" shortcut
+
+ 0.72 (05/03/2011):
+ - Merged Pull Request #23: Added Penner equation approximations from Matthew Lein's Ceaser, and added failsafe fallbacks
+
+ 0.71 (05/03/2011):
+ - Merged Pull Request #24: Changes translation object to integers instead of strings to fix relative values bug with leaveTransforms = true
+
+ 0.70 (17/03/2011):
+ - Merged Pull Request from amlw-nyt to add bottom/right handling
+
+ 0.68 (15/02/2011):
+ - width/height fixes & queue issues resolved.
+
+ 0.67 (15/02/2011):
+ - Code cleanups & file size improvements for compression.
+
+ 0.66 (15/02/2011):
+ - Zero second fadeOut(), fadeIn() fixes
+
+ 0.65 (01/02/2011):
+ - Callbacks with queue() support refactored to support element arrays
+
+ 0.64 (27/01/2011):
+ - BUGFIX #13: .slideUp(), .slideToggle(), .slideDown() bugfixes in Webkit
+
+ 0.63 (12/01/2011):
+ - BUGFIX #11: callbacks not firing when new value == old value
+
+ 0.62 (10/01/2011):
+ - BUGFIX #11: queue is not a function issue fixed
+
+ 0.61 (10/01/2011):
+ - BUGFIX #10: Negative positions converting to positive
+
+ 0.60 (06/01/2011):
+ - Animate function rewrite in accordance with new queue system
+ - BUGFIX #8: Left/top position values always assumed relative rather than absolute
+ - BUGFIX #9: animation as last item in a chain - the chain is ignored?
+ - BUGFIX: width/height CSS3 transformation with left/top working
+
+ 0.55 (22/12/2010):
+ - isEmptyObject function for <jQuery 1.4 (requires 1.3.2)
+
+ 0.54a (22/12/2010):
+ - License changed to MIT (http://www.opensource.org/licenses/mit-license.php)
+
+ 0.54 (22/12/2010):
+ - Removed silly check for 'jQuery UI' bailouts. Sorry.
+ - Scoping issues fixed - Issue #4: $(this) should give you a reference to the selector being animated.. per jquery's core animation funciton.
+
+ 0.53 (17/11/2010):
+ - New $.translate() method to easily calculate current transformed translation
+ - Repeater callback bug fix for leaveTransforms:true (was constantly appending properties)
+
+ 0.52 (16/11/2010):
+ - leaveTransforms: true bug fixes
+ - 'Applying' user callback function to retain 'this' context
+
+ 0.51 (08/11/2010):
+ - Bailing out with jQuery UI. This is only so the plugin plays nice with others and is TEMPORARY.
+
+ 0.50 (08/11/2010):
+ - Support for $.fn.stop()
+ - Fewer jQuery.fn entries to preserve namespace
+ - All references $ converted to jQuery
+ - jsDoc Toolkit style commenting for docs (coming soon)
+
+ 0.49 (19/10/2010):
+ - Handling of 'undefined' errors for secondary CSS objects
+ - Support to enhance 'width' and 'height' properties (except shortcuts involving jQuery.fx.step, e.g slideToggle)
+ - Bugfix: Positioning when using avoidTransforms: true (thanks Ralf Santbergen reports)
+ - Bugfix: Callbacks and Scope issues
+
+ 0.48 (13/10/2010):
+ - Checks for 3d support before applying
+
+ 0.47 (12/10/2010);
+ - Compatible with .fadeIn(), .fadeOut()
+ - Use shortcuts, no duration for jQuery default or "fast" and "slow"
+ - Clean up callback event listeners on complete (preventing multiple callbacks)
+
+ 0.46 (07/10/2010);
+ - Compatible with .slideUp(), .slideDown(), .slideToggle()
+
+ 0.45 (06/10/2010):
+ - 'Zero' position bug fix (was originally translating by 0 zero pixels, i.e. no movement)
+
+ 0.4 (05/10/2010):
+ - Iterate over multiple elements and store transforms in jQuery.data per element
+ - Include support for relative values (+= / -=)
+ - Better unit sanitization
+ - Performance tweaks
+ - Fix for optional callback function (was required)
+ - Applies data[translateX] and data[translateY] to elements for easy access
+ - Added 'easeInOutQuint' easing function for CSS transitions (requires jQuery UI for JS anims)
+ - Less need for leaveTransforms = true due to better position detections
+ */
+
+(function(jQuery, originalAnimateMethod, originalStopMethod) {
+
+    // ----------
+    // Plugin variables
+    // ----------
+    var cssTransitionProperties = ['top', 'right', 'bottom', 'left', 'opacity', 'height', 'width'],
+        directions = ['top', 'right', 'bottom', 'left'],
+        cssPrefixes = ['-webkit-', '-moz-', '-o-', ''],
+        pluginOptions = ['avoidTransforms', 'useTranslate3d', 'leaveTransforms'],
+        rfxnum = /^([+-]=)?([\d+-.]+)(.*)$/,
+        rupper = /([A-Z])/g,
+        defaultEnhanceData = {
+            secondary: {},
+            meta: {
+                top: 0,
+                right: 0,
+                bottom: 0,
+                left: 0
+            }
+        },
+        valUnit = 'px',
+
+        DATA_KEY = 'jQe',
+        CUBIC_BEZIER_OPEN = 'cubic-bezier(',
+        CUBIC_BEZIER_CLOSE = ')',
+
+        originalAnimatedFilter = null,
+        pluginDisabledDefault = false;
+
+    // ----------
+    // Check if this browser supports CSS3 transitions
+    // ----------
+    var thisBody = document.body || document.documentElement,
+        thisStyle = thisBody.style,
+        transitionEndEvent = 'webkitTransitionEnd oTransitionEnd transitionend',
+        cssTransitionsSupported = thisStyle.WebkitTransition !== undefined || thisStyle.MozTransition !== undefined || thisStyle.OTransition !== undefined || thisStyle.transition !== undefined,
+        has3D = ('WebKitCSSMatrix' in window && 'm11' in new WebKitCSSMatrix()),
+        use3DByDefault = has3D;
+
+    // ----------
+    // Extended :animated filter
+    // ----------
+    if (jQuery.expr && jQuery.expr.filters) {
+        originalAnimatedFilter = jQuery.expr.filters.animated;
+        jQuery.expr.filters.animated = function(elem) {
+            return jQuery(elem).data('events') && jQuery(elem).data('events')[transitionEndEvent] ? true : originalAnimatedFilter.call(this, elem);
+        };
+    }
+
+    /**
+     @private
+     @name _getUnit
+     @function
+     @description Return unit value ("px", "%", "em" for re-use correct one when translating)
+     @param {variant} [val] Target value
+     */
+    function _getUnit(val) {
+        return val.match(/\D+$/);
+    }
+
+    /**
+     @private
+     @name _interpretValue
+     @function
+     @description Interpret value ("px", "+=" and "-=" sanitisation)
+     @param {object} [element] The Element for current CSS analysis
+     @param {variant} [val] Target value
+     @param {string} [prop] The property we're looking at
+     @param {boolean} [isTransform] Is this a CSS3 transform?
+     */
+    function _interpretValue(e, val, prop, isTransform) {
+        // this is a nasty fix, but we check for prop == 'd' to see if we're dealing with SVG, and abort
+        if (prop == "d") return;
+        if (!_isValidElement(e)) return;
+
+        var parts = rfxnum.exec(val),
+            start = e.css(prop) === 'auto' ? 0 : e.css(prop),
+            cleanCSSStart = typeof start == 'string' ? _cleanValue(start) : start,
+            cleanTarget = typeof val == 'string' ? _cleanValue(val) : val,
+            cleanStart = isTransform === true ? 0 : cleanCSSStart,
+            hidden = e.is(':hidden'),
+            translation = e.translation();
+
+        if (prop == 'left') cleanStart = parseInt(cleanCSSStart, 10) + translation.x;
+        if (prop == 'right') cleanStart = parseInt(cleanCSSStart, 10) + translation.x;
+        if (prop == 'top') cleanStart = parseInt(cleanCSSStart, 10) + translation.y;
+        if (prop == 'bottom') cleanStart = parseInt(cleanCSSStart, 10) + translation.y;
+
+        // deal with shortcuts
+        if (!parts && val == 'show') {
+            cleanStart = 1;
+            if (hidden) e.css({'display': (e.context.tagName == 'LI') ? 'list-item' : 'block', 'opacity': 0});
+        } else if (!parts && val == "hide") {
+            cleanStart = 0;
+        }
+
+        if (parts) {
+            var end = parseFloat(parts[2]);
+
+            // If a +=/-= token was provided, we're doing a relative animation
+            if (parts[1]) end = ((parts[1] === '-=' ? -1 : 1) * end) + parseInt(cleanStart, 10);
+            return end;
+        } else {
+            return cleanStart;
+        }
+    }
+
+    /**
+     @private
+     @name _getTranslation
+     @function
+     @description Make a translate or translate3d string
+     @param {integer} [x]
+     @param {integer} [y]
+     @param {boolean} [use3D] Use translate3d if available?
+     */
+    function _getTranslation(x, y, use3D) {
+        return ((use3D === true || (use3DByDefault === true && use3D !== false)) && has3D) ? 'translate3d(' + x + 'px, ' + y + 'px, 0)' : 'translate(' + x + 'px,' + y + 'px)';
+    }
+
+    /**
+     @private
+     @name _applyCSSTransition
+     @function
+     @description Build up the CSS object
+     @param {object} [e] Element
+     @param {string} [property] Property we're dealing with
+     @param {integer} [duration] Duration
+     @param {string} [easing] Easing function
+     @param {variant} [value] String/integer for target value
+     @param {boolean} [isTransform] Is this a CSS transformation?
+     @param {boolean} [isTranslatable] Is this a CSS translation?
+     @param {boolean} [use3D] Use translate3d if available?
+     */
+    function _applyCSSTransition(e, property, duration, easing, value, isTransform, isTranslatable, use3D) {
+        var eCSSData = e.data(DATA_KEY),
+            enhanceData = eCSSData && !_isEmptyObject(eCSSData) ? eCSSData : jQuery.extend(true, {}, defaultEnhanceData),
+            offsetPosition = value,
+            isDirection = jQuery.inArray(property, directions) > -1;
+
+        if (isDirection) {
+            var meta = enhanceData.meta,
+                cleanPropertyValue = _cleanValue(e.css(property)) || 0,
+                stashedProperty = property + '_o';
+
+            offsetPosition = value - cleanPropertyValue;
+
+            meta[property] = offsetPosition;
+            meta[stashedProperty] = e.css(property) == 'auto' ? 0 + offsetPosition : cleanPropertyValue + offsetPosition || 0;
+            enhanceData.meta = meta;
+
+            // fix 0 issue (transition by 0 = nothing)
+            if (isTranslatable && offsetPosition === 0) {
+                offsetPosition = 0 - meta[stashedProperty];
+                meta[property] = offsetPosition;
+                meta[stashedProperty] = 0;
+            }
+        }
+
+        // reapply data and return
+        return e.data(DATA_KEY, _applyCSSWithPrefix(e, enhanceData, property, duration, easing, offsetPosition, isTransform, isTranslatable, use3D));
+    }
+
+    /**
+     @private
+     @name _applyCSSWithPrefix
+     @function
+     @description Helper function to build up CSS properties using the various prefixes
+     @param {object} [cssProperties] Current CSS object to merge with
+     @param {string} [property]
+     @param {integer} [duration]
+     @param {string} [easing]
+     @param {variant} [value]
+     @param {boolean} [isTransform] Is this a CSS transformation?
+     @param {boolean} [isTranslatable] Is this a CSS translation?
+     @param {boolean} [use3D] Use translate3d if available?
+     */
+    function _applyCSSWithPrefix(e, cssProperties, property, duration, easing, value, isTransform, isTranslatable, use3D) {
+        var saveOriginal = false,
+            transform = isTransform === true && isTranslatable === true;
+
+        cssProperties = cssProperties || {};
+        if (!cssProperties.original) {
+            cssProperties.original = {};
+            saveOriginal = true;
+        }
+        cssProperties.properties = cssProperties.properties || {};
+        cssProperties.secondary = cssProperties.secondary || {};
+
+        var meta = cssProperties.meta,
+            original = cssProperties.original,
+            properties = cssProperties.properties,
+            secondary = cssProperties.secondary;
+
+        for (var i = cssPrefixes.length - 1; i >= 0; i--) {
+            var tp = cssPrefixes[i] + 'transition-property',
+                td = cssPrefixes[i] + 'transition-duration',
+                tf = cssPrefixes[i] + 'transition-timing-function';
+
+            property = (transform ? cssPrefixes[i] + 'transform' : property);
+
+            if (saveOriginal) {
+                original[tp] = e.css(tp) || '';
+                original[td] = e.css(td) || '';
+                original[tf] = e.css(tf) || '';
+            }
+
+            secondary[property] = transform ? _getTranslation(meta.left, meta.top, use3D) : value;
+
+            properties[tp] = (properties[tp] ? properties[tp] + ',' : '') + property;
+            properties[td] = (properties[td] ? properties[td] + ',' : '') + duration + 'ms';
+            properties[tf] = (properties[tf] ? properties[tf] + ',' : '') + easing;
+        }
+
+        return cssProperties;
+    }
+
+    /**
+     @private
+     @name _isBoxShortcut
+     @function
+     @description Shortcut to detect if we need to step away from slideToggle, CSS accelerated transitions (to come later with fx.step support)
+     @param {object} [prop]
+     */
+    function _isBoxShortcut(prop) {
+        for (var property in prop) {
+            if ((property == 'width' || property == 'height') && (prop[property] == 'show' || prop[property] == 'hide' || prop[property] == 'toggle')) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     @private
+     @name _isEmptyObject
+     @function
+     @description Check if object is empty (<1.4 compatibility)
+     @param {object} [obj]
+     */
+    function _isEmptyObject(obj) {
+        for (var i in obj) {
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     @private
+     @name _cleanValue
+     @function
+     @description Remove 'px' and other artifacts
+     @param {variant} [val]
+     */
+    function _cleanValue(val) {
+        return parseFloat(val.replace(_getUnit(val), ''));
+    }
+
+    function _isValidElement(element) {
+        var allValid = true;
+        element.each(function(index, el) {
+            allValid = allValid && el.ownerDocument;
+            return allValid;
+        });
+        return allValid;
+    }
+
+    /**
+     @private
+     @name _appropriateProperty
+     @function
+     @description Function to check if property should be handled by plugin
+     @param {string} [prop]
+     @param {variant} [value]
+     */
+    function _appropriateProperty(prop, value, element) {
+        if (!_isValidElement(element)) {
+            return false;
+        }
+
+        var is = jQuery.inArray(prop, cssTransitionProperties) > -1;
+        if ((prop == 'width' || prop == 'height' || prop == 'opacity') && (parseFloat(value) === parseFloat(element.css(prop)))) is = false;
+        return is;
+    }
+
+    jQuery.extend({
+        /**
+         @public
+         @name toggle3DByDefault
+         @function
+         @description Toggle for plugin settings to automatically use translate3d (where available). Usage: $.toggle3DByDefault
+         */
+        toggle3DByDefault: function() {
+            return use3DByDefault = !use3DByDefault;
+        },
+
+        /**
+         @public
+         @name toggleEnabledByDefault
+         @function
+         @description Toggle the plugin to be disabled by default (can be overridden per animation with avoidCSSTransitions)
+         */
+        toggleDisabledByDefault: function() {
+            return pluginDisabledDefault = !pluginDisabledDefault;
+        }
+    });
+
+    /**
+     @public
+     @name translation
+     @function
+     @description Get current X and Y translations
+     */
+    jQuery.fn.translation = function() {
+        if (!this[0]) {
+            return null;
+        }
+
+        var elem = this[0],
+            cStyle = window.getComputedStyle(elem, null),
+            translation = {
+                x: 0,
+                y: 0
+            };
+
+        if (cStyle) {
+            for (var i = cssPrefixes.length - 1; i >= 0; i--) {
+                var transform = cStyle.getPropertyValue(cssPrefixes[i] + 'transform');
+                if (transform && (/matrix/i).test(transform)) {
+                    var explodedMatrix = transform.replace(/^matrix\(/i, '').split(/, |\)$/g);
+                    translation = {
+                        x: parseInt(explodedMatrix[4], 10),
+                        y: parseInt(explodedMatrix[5], 10)
+                    };
+
+                    break;
+                }
+            }
+        }
+
+        return translation;
+    };
+
+    /**
+     @public
+     @name jQuery.fn.animate
+     @function
+     @description The enhanced jQuery.animate function
+     @param {string} [property]
+     @param {string} [speed]
+     @param {string} [easing]
+     @param {function} [callback]
+     */
+    jQuery.fn.animate = function(prop, speed, easing, callback) {
+        prop = prop || {};
+        var isTranslatable = !(typeof prop['bottom'] !== 'undefined' || typeof prop['right'] !== 'undefined'),
+            optall = jQuery.speed(speed, easing, callback),
+            elements = this,
+            callbackQueue = 0,
+            propertyCallback = function() {
+                callbackQueue--;
+                if (callbackQueue === 0) {
+                    // we're done, trigger the user callback
+                    if (typeof optall.complete === 'function') {
+                        optall.complete.apply(elements, arguments);
+                    }
+                }
+            },
+            bypassPlugin = (typeof prop['avoidCSSTransitions'] !== 'undefined') ? prop['avoidCSSTransitions'] : pluginDisabledDefault;
+
+        if (bypassPlugin === true || !cssTransitionsSupported || _isEmptyObject(prop) || _isBoxShortcut(prop) || optall.duration <= 0 || (jQuery.fn.animate.defaults.avoidTransforms === true && prop['avoidTransforms'] !== false)) {
+            return originalAnimateMethod.apply(this, arguments);
+        }
+
+        return this[ optall.queue === true ? 'queue' : 'each' ](function() {
+            var self = jQuery(this),
+                opt = jQuery.extend({}, optall),
+                cssCallback = function(e) {
+                    var selfCSSData = self.data(DATA_KEY) || { original: {} },
+                        restore = {};
+
+                    if (e.eventPhase != 2)  // not at dispatching target (thanks @warappa issue #58)
+                        return;
+
+                    // convert translations to left & top for layout
+                    if (prop.leaveTransforms !== true) {
+                        for (var i = cssPrefixes.length - 1; i >= 0; i--) {
+                            restore[cssPrefixes[i] + 'transform'] = '';
+                        }
+                        if (isTranslatable && typeof selfCSSData.meta !== 'undefined') {
+                            for (var j = 0, dir; (dir = directions[j]); ++j) {
+                                restore[dir] = selfCSSData.meta[dir + '_o'] + valUnit;
+                                jQuery(this).css(dir, restore[dir]);
+                            }
+                        }
+                    }
+
+                    // remove transition timing functions
+                    self.
+                        unbind(transitionEndEvent).
+                        css(selfCSSData.original).
+                        css(restore).
+                        data(DATA_KEY, null);
+
+                    // if we used the fadeOut shortcut make sure elements are display:none
+                    if (prop.opacity === 'hide') {
+                        self.css({'display': 'none', 'opacity': ''});
+                    }
+
+                    // run the main callback function
+                    propertyCallback.call(this);
+                },
+                easings = {
+                    bounce: CUBIC_BEZIER_OPEN + '0.0, 0.35, .5, 1.3' + CUBIC_BEZIER_CLOSE,
+                    linear: 'linear',
+                    swing: 'ease-in-out',
+
+                    // Penner equation approximations from Matthew Lein's Ceaser: http://matthewlein.com/ceaser/
+                    easeInQuad: CUBIC_BEZIER_OPEN + '0.550, 0.085, 0.680, 0.530' + CUBIC_BEZIER_CLOSE,
+                    easeInCubic: CUBIC_BEZIER_OPEN + '0.550, 0.055, 0.675, 0.190' + CUBIC_BEZIER_CLOSE,
+                    easeInQuart: CUBIC_BEZIER_OPEN + '0.895, 0.030, 0.685, 0.220' + CUBIC_BEZIER_CLOSE,
+                    easeInQuint: CUBIC_BEZIER_OPEN + '0.755, 0.050, 0.855, 0.060' + CUBIC_BEZIER_CLOSE,
+                    easeInSine: CUBIC_BEZIER_OPEN + '0.470, 0.000, 0.745, 0.715' + CUBIC_BEZIER_CLOSE,
+                    easeInExpo: CUBIC_BEZIER_OPEN + '0.950, 0.050, 0.795, 0.035' + CUBIC_BEZIER_CLOSE,
+                    easeInCirc: CUBIC_BEZIER_OPEN + '0.600, 0.040, 0.980, 0.335' + CUBIC_BEZIER_CLOSE,
+                    easeInBack: CUBIC_BEZIER_OPEN + '0.600, -0.280, 0.735, 0.045' + CUBIC_BEZIER_CLOSE,
+                    easeOutQuad: CUBIC_BEZIER_OPEN + '0.250, 0.460, 0.450, 0.940' + CUBIC_BEZIER_CLOSE,
+                    easeOutCubic: CUBIC_BEZIER_OPEN + '0.215, 0.610, 0.355, 1.000' + CUBIC_BEZIER_CLOSE,
+                    easeOutQuart: CUBIC_BEZIER_OPEN + '0.165, 0.840, 0.440, 1.000' + CUBIC_BEZIER_CLOSE,
+                    easeOutQuint: CUBIC_BEZIER_OPEN + '0.230, 1.000, 0.320, 1.000' + CUBIC_BEZIER_CLOSE,
+                    easeOutSine: CUBIC_BEZIER_OPEN + '0.390, 0.575, 0.565, 1.000' + CUBIC_BEZIER_CLOSE,
+                    easeOutExpo: CUBIC_BEZIER_OPEN + '0.190, 1.000, 0.220, 1.000' + CUBIC_BEZIER_CLOSE,
+                    easeOutCirc: CUBIC_BEZIER_OPEN + '0.075, 0.820, 0.165, 1.000' + CUBIC_BEZIER_CLOSE,
+                    easeOutBack: CUBIC_BEZIER_OPEN + '0.175, 0.885, 0.320, 1.275' + CUBIC_BEZIER_CLOSE,
+                    easeInOutQuad: CUBIC_BEZIER_OPEN + '0.455, 0.030, 0.515, 0.955' + CUBIC_BEZIER_CLOSE,
+                    easeInOutCubic: CUBIC_BEZIER_OPEN + '0.645, 0.045, 0.355, 1.000' + CUBIC_BEZIER_CLOSE,
+                    easeInOutQuart: CUBIC_BEZIER_OPEN + '0.770, 0.000, 0.175, 1.000' + CUBIC_BEZIER_CLOSE,
+                    easeInOutQuint: CUBIC_BEZIER_OPEN + '0.860, 0.000, 0.070, 1.000' + CUBIC_BEZIER_CLOSE,
+                    easeInOutSine: CUBIC_BEZIER_OPEN + '0.445, 0.050, 0.550, 0.950' + CUBIC_BEZIER_CLOSE,
+                    easeInOutExpo: CUBIC_BEZIER_OPEN + '1.000, 0.000, 0.000, 1.000' + CUBIC_BEZIER_CLOSE,
+                    easeInOutCirc: CUBIC_BEZIER_OPEN + '0.785, 0.135, 0.150, 0.860' + CUBIC_BEZIER_CLOSE,
+                    easeInOutBack: CUBIC_BEZIER_OPEN + '0.680, -0.550, 0.265, 1.550' + CUBIC_BEZIER_CLOSE
+                },
+                domProperties = {},
+                cssEasing = easings[opt.easing || 'swing'] ? easings[opt.easing || 'swing'] : opt.easing || 'swing';
+
+            // seperate out the properties for the relevant animation functions
+            for (var p in prop) {
+                if (jQuery.inArray(p, pluginOptions) === -1) {
+                    var isDirection = jQuery.inArray(p, directions) > -1,
+                        cleanVal = _interpretValue(self, prop[p], p, (isDirection && prop.avoidTransforms !== true));
+
+                    if (prop.avoidTransforms !== true && _appropriateProperty(p, cleanVal, self)) {
+                        _applyCSSTransition(
+                            self,
+                            p,
+                            opt.duration,
+                            cssEasing,
+                            isDirection && prop.avoidTransforms === true ? cleanVal + valUnit : cleanVal,
+                            isDirection && prop.avoidTransforms !== true,
+                            isTranslatable,
+                            prop.useTranslate3d === true);
+
+                    }
+                    else {
+                        domProperties[p] = prop[p];
+                    }
+                }
+            }
+
+            self.unbind(transitionEndEvent);
+
+            var selfCSSData = self.data(DATA_KEY);
+
+            if (selfCSSData && !_isEmptyObject(selfCSSData) && !_isEmptyObject(selfCSSData.secondary)) {
+                callbackQueue++;
+
+                self.css(selfCSSData.properties);
+
+                // store in a var to avoid any timing issues, depending on animation duration
+                var secondary = selfCSSData.secondary;
+
+                // has to be done in a timeout to ensure transition properties are set
+                setTimeout(function() {
+                    self.bind(transitionEndEvent, cssCallback).css(secondary);
+                });
+            }
+            else {
+                // it won't get fired otherwise
+                opt.queue = false;
+            }
+
+            // fire up DOM based animations
+            if (!_isEmptyObject(domProperties)) {
+                callbackQueue++;
+                originalAnimateMethod.apply(self, [domProperties, {
+                    duration: opt.duration,
+                    easing: jQuery.easing[opt.easing] ? opt.easing : (jQuery.easing.swing ? 'swing' : 'linear'),
+                    complete: propertyCallback,
+                    queue: opt.queue
+                }]);
+            }
+
+            // strict JS compliance
+            return true;
+        });
+    };
+
+    jQuery.fn.animate.defaults = {};
+
+    /**
+     @public
+     @name jQuery.fn.stop
+     @function
+     @description The enhanced jQuery.stop function (resets transforms to left/top)
+     @param {boolean} [clearQueue]
+     @param {boolean} [gotoEnd]
+     @param {boolean} [leaveTransforms] Leave transforms/translations as they are? Default: false (reset translations to calculated explicit left/top props)
+     */
+    jQuery.fn.stop = function(clearQueue, gotoEnd, leaveTransforms) {
+        if (!cssTransitionsSupported) return originalStopMethod.apply(this, [clearQueue, gotoEnd]);
+
+        // clear the queue?
+        if (clearQueue) this.queue([]);
+
+        // route to appropriate stop methods
+        this.each(function() {
+            var self = jQuery(this),
+                selfCSSData = self.data(DATA_KEY);
+
+            // is this a CSS transition?
+            if (selfCSSData && !_isEmptyObject(selfCSSData)) {
+                var i, restore = {};
+
+                if (gotoEnd) {
+                    // grab end state properties
+                    restore = selfCSSData.secondary;
+
+                    if (!leaveTransforms && typeof selfCSSData.meta['left_o'] !== undefined || typeof selfCSSData.meta['top_o'] !== undefined) {
+                        restore['left'] = typeof selfCSSData.meta['left_o'] !== undefined ? selfCSSData.meta['left_o'] : 'auto';
+                        restore['top'] = typeof selfCSSData.meta['top_o'] !== undefined ? selfCSSData.meta['top_o'] : 'auto';
+
+                        // remove the transformations
+                        for (i = cssPrefixes.length - 1; i >= 0; i--) {
+                            restore[cssPrefixes[i] + 'transform'] = '';
+                        }
+                    }
+                } else if (!_isEmptyObject(selfCSSData.secondary)) {
+                    var cStyle = window.getComputedStyle(self[0], null);
+                    if (cStyle) {
+                        // grab current properties
+                        for (var prop in selfCSSData.secondary) {
+                            if (selfCSSData.secondary.hasOwnProperty(prop)) {
+                                prop = prop.replace(rupper, '-$1').toLowerCase();
+                                restore[prop] = cStyle.getPropertyValue(prop);
+
+                                // is this a matrix property? extract left and top and apply
+                                if (!leaveTransforms && (/matrix/i).test(restore[prop])) {
+                                    var explodedMatrix = restore[prop].replace(/^matrix\(/i, '').split(/, |\)$/g);
+
+                                    // apply the explicit left/top props
+                                    restore['left'] = (parseFloat(explodedMatrix[4]) + parseFloat(self.css('left')) + valUnit) || 'auto';
+                                    restore['top'] = (parseFloat(explodedMatrix[5]) + parseFloat(self.css('top')) + valUnit) || 'auto';
+
+                                    // remove the transformations
+                                    for (i = cssPrefixes.length - 1; i >= 0; i--) {
+                                        restore[cssPrefixes[i] + 'transform'] = '';
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                // Remove transition timing functions
+                // Moving to seperate thread (re: Animation reverts when finished in Android - issue #91)
+                self.unbind(transitionEndEvent);
+                self.
+                    css(selfCSSData.original).
+                    css(restore).
+                    data(DATA_KEY, null);
+            }
+            else {
+                // dom transition
+                originalStopMethod.apply(self, [clearQueue, gotoEnd]);
+            }
+        });
+
+        return this;
+    };
+})(jQuery, jQuery.fn.animate, jQuery.fn.stop);
diff --git a/module/web/static/js/libs/jquery.fastClick-0.2.js b/module/web/static/js/libs/jquery.fastClick-0.2.js
new file mode 100644
index 000000000..49eb75d2a
--- /dev/null
+++ b/module/web/static/js/libs/jquery.fastClick-0.2.js
@@ -0,0 +1,96 @@
+/**
+ * jQuery.fastClick.js
+ *
+ * Work around the 300ms delay for the click event in some mobile browsers.
+ *
+ * Code based on <http://code.google.com/mobile/articles/fast_buttons.html>
+ *
+ * @usage
+ * $('button').fastClick(function() {alert('clicked!');});
+ *
+ * @license Under Creative Commons Attribution 3.0 License
+ * @author Dave Hulbert (dave1010)
+ * @version 0.2 2011-09-20
+ */
+
+/*global document, window, jQuery, Math */
+
+(function($) {
+
+$.fn.fastClick = function(handler) {
+	return $(this).each(function(){
+		$.FastButton($(this)[0], handler);
+	});
+};
+
+$.FastButton = function(element, handler) {
+	var startX, startY;
+
+	var reset = function() {
+		$(element).unbind('touchend');
+		$("body").unbind('touchmove.fastClick');
+	};
+
+	var onClick = function(event) {
+		event.stopPropagation();
+		reset();
+		handler.call(this, event);
+
+		if (event.type === 'touchend') {
+			$.clickbuster.preventGhostClick(startX, startY);
+		}
+	};
+
+	var onTouchMove = function(event) {
+		if (Math.abs(event.originalEvent.touches[0].clientX - startX) > 10 ||
+			Math.abs(event.originalEvent.touches[0].clientY - startY) > 10) {
+			reset();
+		}
+	};
+
+	var onTouchStart = function(event) {
+		event.stopPropagation();
+
+		$(element).bind('touchend', onClick);
+		$("body").bind('touchmove.fastClick', onTouchMove);
+
+		startX = event.originalEvent.touches[0].clientX;
+		startY = event.originalEvent.touches[0].clientY;
+	};
+
+	$(element).bind({
+		touchstart: onTouchStart,
+		click: onClick
+	});
+};
+
+$.clickbuster = {
+	coordinates: [],
+
+	preventGhostClick: function(x, y) {
+		$.clickbuster.coordinates.push(x, y);
+		window.setTimeout($.clickbuster.pop, 2500);
+	},
+
+	pop: function() {
+		$.clickbuster.coordinates.splice(0, 2);
+	},
+
+	onClick: function(event) {
+		var x, y, i;
+		for (i = 0; i < $.clickbuster.coordinates.length; i += 2) {
+			x = $.clickbuster.coordinates[i];
+			y = $.clickbuster.coordinates[i + 1];
+			if (Math.abs(event.clientX - x) < 25 && Math.abs(event.clientY - y) < 25) {
+				event.stopPropagation();
+				event.preventDefault();
+			}
+		}
+	}
+};
+
+$(function(){
+	document.addEventListener('click', $.clickbuster.onClick, true);
+});
+
+}(jQuery));
diff --git a/module/web/static/js/libs/jquery.flot-1.1.js b/module/web/static/js/libs/jquery.flot-1.1.js
new file mode 100644
index 000000000..aabc544e9
--- /dev/null
+++ b/module/web/static/js/libs/jquery.flot-1.1.js
@@ -0,0 +1,2599 @@
+/*! Javascript plotting library for jQuery, v. 0.7.
+ *
+ * Released under the MIT license by IOLA, December 2007.
+ *
+ */
+
+// first an inline dependency, jquery.colorhelpers.js, we inline it here
+// for convenience
+
+/* Plugin for jQuery for working with colors.
+ * 
+ * Version 1.1.
+ * 
+ * Inspiration from jQuery color animation plugin by John Resig.
+ *
+ * Released under the MIT license by Ole Laursen, October 2009.
+ *
+ * Examples:
+ *
+ *   $.color.parse("#fff").scale('rgb', 0.25).add('a', -0.5).toString()
+ *   var c = $.color.extract($("#mydiv"), 'background-color');
+ *   console.log(c.r, c.g, c.b, c.a);
+ *   $.color.make(100, 50, 25, 0.4).toString() // returns "rgba(100,50,25,0.4)"
+ *
+ * Note that .scale() and .add() return the same modified object
+ * instead of making a new one.
+ *
+ * V. 1.1: Fix error handling so e.g. parsing an empty string does
+ * produce a color rather than just crashing.
+ */ 
+(function(B){B.color={};B.color.make=function(F,E,C,D){var G={};G.r=F||0;G.g=E||0;G.b=C||0;G.a=D!=null?D:1;G.add=function(J,I){for(var H=0;H<J.length;++H){G[J.charAt(H)]+=I}return G.normalize()};G.scale=function(J,I){for(var H=0;H<J.length;++H){G[J.charAt(H)]*=I}return G.normalize()};G.toString=function(){if(G.a>=1){return"rgb("+[G.r,G.g,G.b].join(",")+")"}else{return"rgba("+[G.r,G.g,G.b,G.a].join(",")+")"}};G.normalize=function(){function H(J,K,I){return K<J?J:(K>I?I:K)}G.r=H(0,parseInt(G.r),255);G.g=H(0,parseInt(G.g),255);G.b=H(0,parseInt(G.b),255);G.a=H(0,G.a,1);return G};G.clone=function(){return B.color.make(G.r,G.b,G.g,G.a)};return G.normalize()};B.color.extract=function(D,C){var E;do{E=D.css(C).toLowerCase();if(E!=""&&E!="transparent"){break}D=D.parent()}while(!B.nodeName(D.get(0),"body"));if(E=="rgba(0, 0, 0, 0)"){E="transparent"}return B.color.parse(E)};B.color.parse=function(F){var E,C=B.color.make;if(E=/rgb\(\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*\)/.exec(F)){return C(parseInt(E[1],10),parseInt(E[2],10),parseInt(E[3],10))}if(E=/rgba\(\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]+(?:\.[0-9]+)?)\s*\)/.exec(F)){return C(parseInt(E[1],10),parseInt(E[2],10),parseInt(E[3],10),parseFloat(E[4]))}if(E=/rgb\(\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*\)/.exec(F)){return C(parseFloat(E[1])*2.55,parseFloat(E[2])*2.55,parseFloat(E[3])*2.55)}if(E=/rgba\(\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\s*\)/.exec(F)){return C(parseFloat(E[1])*2.55,parseFloat(E[2])*2.55,parseFloat(E[3])*2.55,parseFloat(E[4]))}if(E=/#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})/.exec(F)){return C(parseInt(E[1],16),parseInt(E[2],16),parseInt(E[3],16))}if(E=/#([a-fA-F0-9])([a-fA-F0-9])([a-fA-F0-9])/.exec(F)){return C(parseInt(E[1]+E[1],16),parseInt(E[2]+E[2],16),parseInt(E[3]+E[3],16))}var D=B.trim(F).toLowerCase();if(D=="transparent"){return C(255,255,255,0)}else{E=A[D]||[0,0,0];return C(E[0],E[1],E[2])}};var A={aqua:[0,255,255],azure:[240,255,255],beige:[245,245,220],black:[0,0,0],blue:[0,0,255],brown:[165,42,42],cyan:[0,255,255],darkblue:[0,0,139],darkcyan:[0,139,139],darkgrey:[169,169,169],darkgreen:[0,100,0],darkkhaki:[189,183,107],darkmagenta:[139,0,139],darkolivegreen:[85,107,47],darkorange:[255,140,0],darkorchid:[153,50,204],darkred:[139,0,0],darksalmon:[233,150,122],darkviolet:[148,0,211],fuchsia:[255,0,255],gold:[255,215,0],green:[0,128,0],indigo:[75,0,130],khaki:[240,230,140],lightblue:[173,216,230],lightcyan:[224,255,255],lightgreen:[144,238,144],lightgrey:[211,211,211],lightpink:[255,182,193],lightyellow:[255,255,224],lime:[0,255,0],magenta:[255,0,255],maroon:[128,0,0],navy:[0,0,128],olive:[128,128,0],orange:[255,165,0],pink:[255,192,203],purple:[128,0,128],violet:[128,0,128],red:[255,0,0],silver:[192,192,192],white:[255,255,255],yellow:[255,255,0]}})(jQuery);
+
+// the actual Flot code
+(function($) {
+    function Plot(placeholder, data_, options_, plugins) {
+        // data is on the form:
+        //   [ series1, series2 ... ]
+        // where series is either just the data as [ [x1, y1], [x2, y2], ... ]
+        // or { data: [ [x1, y1], [x2, y2], ... ], label: "some label", ... }
+        
+        var series = [],
+            options = {
+                // the color theme used for graphs
+                colors: ["#edc240", "#afd8f8", "#cb4b4b", "#4da74d", "#9440ed"],
+                legend: {
+                    show: true,
+                    noColumns: 1, // number of colums in legend table
+                    labelFormatter: null, // fn: string -> string
+                    labelBoxBorderColor: "#ccc", // border color for the little label boxes
+                    container: null, // container (as jQuery object) to put legend in, null means default on top of graph
+                    position: "ne", // position of default legend container within plot
+                    margin: 5, // distance from grid edge to default legend container within plot
+                    backgroundColor: null, // null means auto-detect
+                    backgroundOpacity: 0.85 // set to 0 to avoid background
+                },
+                xaxis: {
+                    show: null, // null = auto-detect, true = always, false = never
+                    position: "bottom", // or "top"
+                    mode: null, // null or "time"
+                    color: null, // base color, labels, ticks
+                    tickColor: null, // possibly different color of ticks, e.g. "rgba(0,0,0,0.15)"
+                    transform: null, // null or f: number -> number to transform axis
+                    inverseTransform: null, // if transform is set, this should be the inverse function
+                    min: null, // min. value to show, null means set automatically
+                    max: null, // max. value to show, null means set automatically
+                    autoscaleMargin: null, // margin in % to add if auto-setting min/max
+                    ticks: null, // either [1, 3] or [[1, "a"], 3] or (fn: axis info -> ticks) or app. number of ticks for auto-ticks
+                    tickFormatter: null, // fn: number -> string
+                    labelWidth: null, // size of tick labels in pixels
+                    labelHeight: null,
+                    reserveSpace: null, // whether to reserve space even if axis isn't shown
+                    tickLength: null, // size in pixels of ticks, or "full" for whole line
+                    alignTicksWithAxis: null, // axis number or null for no sync
+                    
+                    // mode specific options
+                    tickDecimals: null, // no. of decimals, null means auto
+                    tickSize: null, // number or [number, "unit"]
+                    minTickSize: null, // number or [number, "unit"]
+                    monthNames: null, // list of names of months
+                    timeformat: null, // format string to use
+                    twelveHourClock: false // 12 or 24 time in time mode
+                },
+                yaxis: {
+                    autoscaleMargin: 0.02,
+                    position: "left" // or "right"
+                },
+                xaxes: [],
+                yaxes: [],
+                series: {
+                    points: {
+                        show: false,
+                        radius: 3,
+                        lineWidth: 2, // in pixels
+                        fill: true,
+                        fillColor: "#ffffff",
+                        symbol: "circle" // or callback
+                    },
+                    lines: {
+                        // we don't put in show: false so we can see
+                        // whether lines were actively disabled 
+                        lineWidth: 2, // in pixels
+                        fill: false,
+                        fillColor: null,
+                        steps: false
+                    },
+                    bars: {
+                        show: false,
+                        lineWidth: 2, // in pixels
+                        barWidth: 1, // in units of the x axis
+                        fill: true,
+                        fillColor: null,
+                        align: "left", // or "center" 
+                        horizontal: false
+                    },
+                    shadowSize: 3
+                },
+                grid: {
+                    show: true,
+                    aboveData: false,
+                    color: "#545454", // primary color used for outline and labels
+                    backgroundColor: null, // null for transparent, else color
+                    borderColor: null, // set if different from the grid color
+                    tickColor: null, // color for the ticks, e.g. "rgba(0,0,0,0.15)"
+                    labelMargin: 5, // in pixels
+                    axisMargin: 8, // in pixels
+                    borderWidth: 2, // in pixels
+                    minBorderMargin: null, // in pixels, null means taken from points radius
+                    markings: null, // array of ranges or fn: axes -> array of ranges
+                    markingsColor: "#f4f4f4",
+                    markingsLineWidth: 2,
+                    // interactive stuff
+                    clickable: false,
+                    hoverable: false,
+                    autoHighlight: true, // highlight in case mouse is near
+                    mouseActiveRadius: 10 // how far the mouse can be away to activate an item
+                },
+                hooks: {}
+            },
+        canvas = null,      // the canvas for the plot itself
+        overlay = null,     // canvas for interactive stuff on top of plot
+        eventHolder = null, // jQuery object that events should be bound to
+        ctx = null, octx = null,
+        xaxes = [], yaxes = [],
+        plotOffset = { left: 0, right: 0, top: 0, bottom: 0},
+        canvasWidth = 0, canvasHeight = 0,
+        plotWidth = 0, plotHeight = 0,
+        hooks = {
+            processOptions: [],
+            processRawData: [],
+            processDatapoints: [],
+            drawSeries: [],
+            draw: [],
+            bindEvents: [],
+            drawOverlay: [],
+            shutdown: []
+        },
+        plot = this;
+
+        // public functions
+        plot.setData = setData;
+        plot.setupGrid = setupGrid;
+        plot.draw = draw;
+        plot.getPlaceholder = function() { return placeholder; };
+        plot.getCanvas = function() { return canvas; };
+        plot.getPlotOffset = function() { return plotOffset; };
+        plot.width = function () { return plotWidth; };
+        plot.height = function () { return plotHeight; };
+        plot.offset = function () {
+            var o = eventHolder.offset();
+            o.left += plotOffset.left;
+            o.top += plotOffset.top;
+            return o;
+        };
+        plot.getData = function () { return series; };
+        plot.getAxes = function () {
+            var res = {}, i;
+            $.each(xaxes.concat(yaxes), function (_, axis) {
+                if (axis)
+                    res[axis.direction + (axis.n != 1 ? axis.n : "") + "axis"] = axis;
+            });
+            return res;
+        };
+        plot.getXAxes = function () { return xaxes; };
+        plot.getYAxes = function () { return yaxes; };
+        plot.c2p = canvasToAxisCoords;
+        plot.p2c = axisToCanvasCoords;
+        plot.getOptions = function () { return options; };
+        plot.highlight = highlight;
+        plot.unhighlight = unhighlight;
+        plot.triggerRedrawOverlay = triggerRedrawOverlay;
+        plot.pointOffset = function(point) {
+            return {
+                left: parseInt(xaxes[axisNumber(point, "x") - 1].p2c(+point.x) + plotOffset.left),
+                top: parseInt(yaxes[axisNumber(point, "y") - 1].p2c(+point.y) + plotOffset.top)
+            };
+        };
+        plot.shutdown = shutdown;
+        plot.resize = function () {
+            getCanvasDimensions();
+            resizeCanvas(canvas);
+            resizeCanvas(overlay);
+        };
+
+        // public attributes
+        plot.hooks = hooks;
+        
+        // initialize
+        initPlugins(plot);
+        parseOptions(options_);
+        setupCanvases();
+        setData(data_);
+        setupGrid();
+        draw();
+        bindEvents();
+
+
+        function executeHooks(hook, args) {
+            args = [plot].concat(args);
+            for (var i = 0; i < hook.length; ++i)
+                hook[i].apply(this, args);
+        }
+
+        function initPlugins() {
+            for (var i = 0; i < plugins.length; ++i) {
+                var p = plugins[i];
+                p.init(plot);
+                if (p.options)
+                    $.extend(true, options, p.options);
+            }
+        }
+        
+        function parseOptions(opts) {
+            var i;
+            
+            $.extend(true, options, opts);
+            
+            if (options.xaxis.color == null)
+                options.xaxis.color = options.grid.color;
+            if (options.yaxis.color == null)
+                options.yaxis.color = options.grid.color;
+            
+            if (options.xaxis.tickColor == null) // backwards-compatibility
+                options.xaxis.tickColor = options.grid.tickColor;
+            if (options.yaxis.tickColor == null) // backwards-compatibility
+                options.yaxis.tickColor = options.grid.tickColor;
+
+            if (options.grid.borderColor == null)
+                options.grid.borderColor = options.grid.color;
+            if (options.grid.tickColor == null)
+                options.grid.tickColor = $.color.parse(options.grid.color).scale('a', 0.22).toString();
+            
+            // fill in defaults in axes, copy at least always the
+            // first as the rest of the code assumes it'll be there
+            for (i = 0; i < Math.max(1, options.xaxes.length); ++i)
+                options.xaxes[i] = $.extend(true, {}, options.xaxis, options.xaxes[i]);
+            for (i = 0; i < Math.max(1, options.yaxes.length); ++i)
+                options.yaxes[i] = $.extend(true, {}, options.yaxis, options.yaxes[i]);
+
+            // backwards compatibility, to be removed in future
+            if (options.xaxis.noTicks && options.xaxis.ticks == null)
+                options.xaxis.ticks = options.xaxis.noTicks;
+            if (options.yaxis.noTicks && options.yaxis.ticks == null)
+                options.yaxis.ticks = options.yaxis.noTicks;
+            if (options.x2axis) {
+                options.xaxes[1] = $.extend(true, {}, options.xaxis, options.x2axis);
+                options.xaxes[1].position = "top";
+            }
+            if (options.y2axis) {
+                options.yaxes[1] = $.extend(true, {}, options.yaxis, options.y2axis);
+                options.yaxes[1].position = "right";
+            }
+            if (options.grid.coloredAreas)
+                options.grid.markings = options.grid.coloredAreas;
+            if (options.grid.coloredAreasColor)
+                options.grid.markingsColor = options.grid.coloredAreasColor;
+            if (options.lines)
+                $.extend(true, options.series.lines, options.lines);
+            if (options.points)
+                $.extend(true, options.series.points, options.points);
+            if (options.bars)
+                $.extend(true, options.series.bars, options.bars);
+            if (options.shadowSize != null)
+                options.series.shadowSize = options.shadowSize;
+
+            // save options on axes for future reference
+            for (i = 0; i < options.xaxes.length; ++i)
+                getOrCreateAxis(xaxes, i + 1).options = options.xaxes[i];
+            for (i = 0; i < options.yaxes.length; ++i)
+                getOrCreateAxis(yaxes, i + 1).options = options.yaxes[i];
+
+            // add hooks from options
+            for (var n in hooks)
+                if (options.hooks[n] && options.hooks[n].length)
+                    hooks[n] = hooks[n].concat(options.hooks[n]);
+
+            executeHooks(hooks.processOptions, [options]);
+        }
+
+        function setData(d) {
+            series = parseData(d);
+            fillInSeriesOptions();
+            processData();
+        }
+        
+        function parseData(d) {
+            var res = [];
+            for (var i = 0; i < d.length; ++i) {
+                var s = $.extend(true, {}, options.series);
+
+                if (d[i].data != null) {
+                    s.data = d[i].data; // move the data instead of deep-copy
+                    delete d[i].data;
+
+                    $.extend(true, s, d[i]);
+
+                    d[i].data = s.data;
+                }
+                else
+                    s.data = d[i];
+                res.push(s);
+            }
+
+            return res;
+        }
+        
+        function axisNumber(obj, coord) {
+            var a = obj[coord + "axis"];
+            if (typeof a == "object") // if we got a real axis, extract number
+                a = a.n;
+            if (typeof a != "number")
+                a = 1; // default to first axis
+            return a;
+        }
+
+        function allAxes() {
+            // return flat array without annoying null entries
+            return $.grep(xaxes.concat(yaxes), function (a) { return a; });
+        }
+        
+        function canvasToAxisCoords(pos) {
+            // return an object with x/y corresponding to all used axes 
+            var res = {}, i, axis;
+            for (i = 0; i < xaxes.length; ++i) {
+                axis = xaxes[i];
+                if (axis && axis.used)
+                    res["x" + axis.n] = axis.c2p(pos.left);
+            }
+
+            for (i = 0; i < yaxes.length; ++i) {
+                axis = yaxes[i];
+                if (axis && axis.used)
+                    res["y" + axis.n] = axis.c2p(pos.top);
+            }
+            
+            if (res.x1 !== undefined)
+                res.x = res.x1;
+            if (res.y1 !== undefined)
+                res.y = res.y1;
+
+            return res;
+        }
+        
+        function axisToCanvasCoords(pos) {
+            // get canvas coords from the first pair of x/y found in pos
+            var res = {}, i, axis, key;
+
+            for (i = 0; i < xaxes.length; ++i) {
+                axis = xaxes[i];
+                if (axis && axis.used) {
+                    key = "x" + axis.n;
+                    if (pos[key] == null && axis.n == 1)
+                        key = "x";
+
+                    if (pos[key] != null) {
+                        res.left = axis.p2c(pos[key]);
+                        break;
+                    }
+                }
+            }
+            
+            for (i = 0; i < yaxes.length; ++i) {
+                axis = yaxes[i];
+                if (axis && axis.used) {
+                    key = "y" + axis.n;
+                    if (pos[key] == null && axis.n == 1)
+                        key = "y";
+
+                    if (pos[key] != null) {
+                        res.top = axis.p2c(pos[key]);
+                        break;
+                    }
+                }
+            }
+            
+            return res;
+        }
+        
+        function getOrCreateAxis(axes, number) {
+            if (!axes[number - 1])
+                axes[number - 1] = {
+                    n: number, // save the number for future reference
+                    direction: axes == xaxes ? "x" : "y",
+                    options: $.extend(true, {}, axes == xaxes ? options.xaxis : options.yaxis)
+                };
+                
+            return axes[number - 1];
+        }
+
+        function fillInSeriesOptions() {
+            var i;
+            
+            // collect what we already got of colors
+            var neededColors = series.length,
+                usedColors = [],
+                assignedColors = [];
+            for (i = 0; i < series.length; ++i) {
+                var sc = series[i].color;
+                if (sc != null) {
+                    --neededColors;
+                    if (typeof sc == "number")
+                        assignedColors.push(sc);
+                    else
+                        usedColors.push($.color.parse(series[i].color));
+                }
+            }
+            
+            // we might need to generate more colors if higher indices
+            // are assigned
+            for (i = 0; i < assignedColors.length; ++i) {
+                neededColors = Math.max(neededColors, assignedColors[i] + 1);
+            }
+
+            // produce colors as needed
+            var colors = [], variation = 0;
+            i = 0;
+            while (colors.length < neededColors) {
+                var c;
+                if (options.colors.length == i) // check degenerate case
+                    c = $.color.make(100, 100, 100);
+                else
+                    c = $.color.parse(options.colors[i]);
+
+                // vary color if needed
+                var sign = variation % 2 == 1 ? -1 : 1;
+                c.scale('rgb', 1 + sign * Math.ceil(variation / 2) * 0.2)
+
+                // FIXME: if we're getting to close to something else,
+                // we should probably skip this one
+                colors.push(c);
+                
+                ++i;
+                if (i >= options.colors.length) {
+                    i = 0;
+                    ++variation;
+                }
+            }
+
+            // fill in the options
+            var colori = 0, s;
+            for (i = 0; i < series.length; ++i) {
+                s = series[i];
+                
+                // assign colors
+                if (s.color == null) {
+                    s.color = colors[colori].toString();
+                    ++colori;
+                }
+                else if (typeof s.color == "number")
+                    s.color = colors[s.color].toString();
+
+                // turn on lines automatically in case nothing is set
+                if (s.lines.show == null) {
+                    var v, show = true;
+                    for (v in s)
+                        if (s[v] && s[v].show) {
+                            show = false;
+                            break;
+                        }
+                    if (show)
+                        s.lines.show = true;
+                }
+
+                // setup axes
+                s.xaxis = getOrCreateAxis(xaxes, axisNumber(s, "x"));
+                s.yaxis = getOrCreateAxis(yaxes, axisNumber(s, "y"));
+            }
+        }
+        
+        function processData() {
+            var topSentry = Number.POSITIVE_INFINITY,
+                bottomSentry = Number.NEGATIVE_INFINITY,
+                fakeInfinity = Number.MAX_VALUE,
+                i, j, k, m, length,
+                s, points, ps, x, y, axis, val, f, p;
+
+            function updateAxis(axis, min, max) {
+                if (min < axis.datamin && min != -fakeInfinity)
+                    axis.datamin = min;
+                if (max > axis.datamax && max != fakeInfinity)
+                    axis.datamax = max;
+            }
+
+            $.each(allAxes(), function (_, axis) {
+                // init axis
+                axis.datamin = topSentry;
+                axis.datamax = bottomSentry;
+                axis.used = false;
+            });
+            
+            for (i = 0; i < series.length; ++i) {
+                s = series[i];
+                s.datapoints = { points: [] };
+                
+                executeHooks(hooks.processRawData, [ s, s.data, s.datapoints ]);
+            }
+            
+            // first pass: clean and copy data
+            for (i = 0; i < series.length; ++i) {
+                s = series[i];
+
+                var data = s.data, format = s.datapoints.format;
+
+                if (!format) {
+                    format = [];
+                    // find out how to copy
+                    format.push({ x: true, number: true, required: true });
+                    format.push({ y: true, number: true, required: true });
+
+                    if (s.bars.show || (s.lines.show && s.lines.fill)) {
+                        format.push({ y: true, number: true, required: false, defaultValue: 0 });
+                        if (s.bars.horizontal) {
+                            delete format[format.length - 1].y;
+                            format[format.length - 1].x = true;
+                        }
+                    }
+                    
+                    s.datapoints.format = format;
+                }
+
+                if (s.datapoints.pointsize != null)
+                    continue; // already filled in
+
+                s.datapoints.pointsize = format.length;
+                
+                ps = s.datapoints.pointsize;
+                points = s.datapoints.points;
+
+                insertSteps = s.lines.show && s.lines.steps;
+                s.xaxis.used = s.yaxis.used = true;
+                
+                for (j = k = 0; j < data.length; ++j, k += ps) {
+                    p = data[j];
+
+                    var nullify = p == null;
+                    if (!nullify) {
+                        for (m = 0; m < ps; ++m) {
+                            val = p[m];
+                            f = format[m];
+
+                            if (f) {
+                                if (f.number && val != null) {
+                                    val = +val; // convert to number
+                                    if (isNaN(val))
+                                        val = null;
+                                    else if (val == Infinity)
+                                        val = fakeInfinity;
+                                    else if (val == -Infinity)
+                                        val = -fakeInfinity;
+                                }
+
+                                if (val == null) {
+                                    if (f.required)
+                                        nullify = true;
+                                    
+                                    if (f.defaultValue != null)
+                                        val = f.defaultValue;
+                                }
+                            }
+                            
+                            points[k + m] = val;
+                        }
+                    }
+                    
+                    if (nullify) {
+                        for (m = 0; m < ps; ++m) {
+                            val = points[k + m];
+                            if (val != null) {
+                                f = format[m];
+                                // extract min/max info
+                                if (f.x)
+                                    updateAxis(s.xaxis, val, val);
+                                if (f.y)
+                                    updateAxis(s.yaxis, val, val);
+                            }
+                            points[k + m] = null;
+                        }
+                    }
+                    else {
+                        // a little bit of line specific stuff that
+                        // perhaps shouldn't be here, but lacking
+                        // better means...
+                        if (insertSteps && k > 0
+                            && points[k - ps] != null
+                            && points[k - ps] != points[k]
+                            && points[k - ps + 1] != points[k + 1]) {
+                            // copy the point to make room for a middle point
+                            for (m = 0; m < ps; ++m)
+                                points[k + ps + m] = points[k + m];
+
+                            // middle point has same y
+                            points[k + 1] = points[k - ps + 1];
+
+                            // we've added a point, better reflect that
+                            k += ps;
+                        }
+                    }
+                }
+            }
+
+            // give the hooks a chance to run
+            for (i = 0; i < series.length; ++i) {
+                s = series[i];
+                
+                executeHooks(hooks.processDatapoints, [ s, s.datapoints]);
+            }
+
+            // second pass: find datamax/datamin for auto-scaling
+            for (i = 0; i < series.length; ++i) {
+                s = series[i];
+                points = s.datapoints.points,
+                ps = s.datapoints.pointsize;
+
+                var xmin = topSentry, ymin = topSentry,
+                    xmax = bottomSentry, ymax = bottomSentry;
+                
+                for (j = 0; j < points.length; j += ps) {
+                    if (points[j] == null)
+                        continue;
+
+                    for (m = 0; m < ps; ++m) {
+                        val = points[j + m];
+                        f = format[m];
+                        if (!f || val == fakeInfinity || val == -fakeInfinity)
+                            continue;
+                        
+                        if (f.x) {
+                            if (val < xmin)
+                                xmin = val;
+                            if (val > xmax)
+                                xmax = val;
+                        }
+                        if (f.y) {
+                            if (val < ymin)
+                                ymin = val;
+                            if (val > ymax)
+                                ymax = val;
+                        }
+                    }
+                }
+                
+                if (s.bars.show) {
+                    // make sure we got room for the bar on the dancing floor
+                    var delta = s.bars.align == "left" ? 0 : -s.bars.barWidth/2;
+                    if (s.bars.horizontal) {
+                        ymin += delta;
+                        ymax += delta + s.bars.barWidth;
+                    }
+                    else {
+                        xmin += delta;
+                        xmax += delta + s.bars.barWidth;
+                    }
+                }
+                
+                updateAxis(s.xaxis, xmin, xmax);
+                updateAxis(s.yaxis, ymin, ymax);
+            }
+
+            $.each(allAxes(), function (_, axis) {
+                if (axis.datamin == topSentry)
+                    axis.datamin = null;
+                if (axis.datamax == bottomSentry)
+                    axis.datamax = null;
+            });
+        }
+
+        function makeCanvas(skipPositioning, cls) {
+            var c = document.createElement('canvas');
+            c.className = cls;
+            c.width = canvasWidth;
+            c.height = canvasHeight;
+                    
+            if (!skipPositioning)
+                $(c).css({ position: 'absolute', left: 0, top: 0 });
+                
+            $(c).appendTo(placeholder);
+                
+            if (!c.getContext) // excanvas hack
+                c = window.G_vmlCanvasManager.initElement(c);
+
+            // used for resetting in case we get replotted
+            c.getContext("2d").save();
+            
+            return c;
+        }
+
+        function getCanvasDimensions() {
+            canvasWidth = placeholder.width();
+            canvasHeight = placeholder.height();
+            
+            if (canvasWidth <= 0 || canvasHeight <= 0)
+                throw "Invalid dimensions for plot, width = " + canvasWidth + ", height = " + canvasHeight;
+        }
+
+        function resizeCanvas(c) {
+            // resizing should reset the state (excanvas seems to be
+            // buggy though)
+            if (c.width != canvasWidth)
+                c.width = canvasWidth;
+
+            if (c.height != canvasHeight)
+                c.height = canvasHeight;
+
+            // so try to get back to the initial state (even if it's
+            // gone now, this should be safe according to the spec)
+            var cctx = c.getContext("2d");
+            cctx.restore();
+
+            // and save again
+            cctx.save();
+        }
+        
+        function setupCanvases() {
+            var reused,
+                existingCanvas = placeholder.children("canvas.base"),
+                existingOverlay = placeholder.children("canvas.overlay");
+
+            if (existingCanvas.length == 0 || existingOverlay == 0) {
+                // init everything
+                
+                placeholder.html(""); // make sure placeholder is clear
+            
+                placeholder.css({ padding: 0 }); // padding messes up the positioning
+                
+                if (placeholder.css("position") == 'static')
+                    placeholder.css("position", "relative"); // for positioning labels and overlay
+
+                getCanvasDimensions();
+                
+                canvas = makeCanvas(true, "base");
+                overlay = makeCanvas(false, "overlay"); // overlay canvas for interactive features
+
+                reused = false;
+            }
+            else {
+                // reuse existing elements
+
+                canvas = existingCanvas.get(0);
+                overlay = existingOverlay.get(0);
+
+                reused = true;
+            }
+
+            ctx = canvas.getContext("2d");
+            octx = overlay.getContext("2d");
+
+            // we include the canvas in the event holder too, because IE 7
+            // sometimes has trouble with the stacking order
+            eventHolder = $([overlay, canvas]);
+
+            if (reused) {
+                // run shutdown in the old plot object
+                placeholder.data("plot").shutdown();
+
+                // reset reused canvases
+                plot.resize();
+                
+                // make sure overlay pixels are cleared (canvas is cleared when we redraw)
+                octx.clearRect(0, 0, canvasWidth, canvasHeight);
+                
+                // then whack any remaining obvious garbage left
+                eventHolder.unbind();
+                placeholder.children().not([canvas, overlay]).remove();
+            }
+
+            // save in case we get replotted
+            placeholder.data("plot", plot);
+        }
+
+        function bindEvents() {
+            // bind events
+            if (options.grid.hoverable) {
+                eventHolder.mousemove(onMouseMove);
+                eventHolder.mouseleave(onMouseLeave);
+            }
+
+            if (options.grid.clickable)
+                eventHolder.click(onClick);
+
+            executeHooks(hooks.bindEvents, [eventHolder]);
+        }
+
+        function shutdown() {
+            if (redrawTimeout)
+                clearTimeout(redrawTimeout);
+            
+            eventHolder.unbind("mousemove", onMouseMove);
+            eventHolder.unbind("mouseleave", onMouseLeave);
+            eventHolder.unbind("click", onClick);
+            
+            executeHooks(hooks.shutdown, [eventHolder]);
+        }
+
+        function setTransformationHelpers(axis) {
+            // set helper functions on the axis, assumes plot area
+            // has been computed already
+            
+            function identity(x) { return x; }
+            
+            var s, m, t = axis.options.transform || identity,
+                it = axis.options.inverseTransform;
+            
+            // precompute how much the axis is scaling a point
+            // in canvas space
+            if (axis.direction == "x") {
+                s = axis.scale = plotWidth / Math.abs(t(axis.max) - t(axis.min));
+                m = Math.min(t(axis.max), t(axis.min));
+            }
+            else {
+                s = axis.scale = plotHeight / Math.abs(t(axis.max) - t(axis.min));
+                s = -s;
+                m = Math.max(t(axis.max), t(axis.min));
+            }
+
+            // data point to canvas coordinate
+            if (t == identity) // slight optimization
+                axis.p2c = function (p) { return (p - m) * s; };
+            else
+                axis.p2c = function (p) { return (t(p) - m) * s; };
+            // canvas coordinate to data point
+            if (!it)
+                axis.c2p = function (c) { return m + c / s; };
+            else
+                axis.c2p = function (c) { return it(m + c / s); };
+        }
+
+        function measureTickLabels(axis) {
+            var opts = axis.options, i, ticks = axis.ticks || [], labels = [],
+                l, w = opts.labelWidth, h = opts.labelHeight, dummyDiv;
+
+            function makeDummyDiv(labels, width) {
+                return $('<div style="position:absolute;top:-10000px;' + width + 'font-size:smaller">' +
+                         '<div class="' + axis.direction + 'Axis ' + axis.direction + axis.n + 'Axis">'
+                         + labels.join("") + '</div></div>')
+                    .appendTo(placeholder);
+            }
+            
+            if (axis.direction == "x") {
+                // to avoid measuring the widths of the labels (it's slow), we
+                // construct fixed-size boxes and put the labels inside
+                // them, we don't need the exact figures and the
+                // fixed-size box content is easy to center
+                if (w == null)
+                    w = Math.floor(canvasWidth / (ticks.length > 0 ? ticks.length : 1));
+
+                // measure x label heights
+                if (h == null) {
+                    labels = [];
+                    for (i = 0; i < ticks.length; ++i) {
+                        l = ticks[i].label;
+                        if (l)
+                            labels.push('<div class="tickLabel" style="float:left;width:' + w + 'px">' + l + '</div>');
+                    }
+
+                    if (labels.length > 0) {
+                        // stick them all in the same div and measure
+                        // collective height
+                        labels.push('<div style="clear:left"></div>');
+                        dummyDiv = makeDummyDiv(labels, "width:10000px;");
+                        h = dummyDiv.height();
+                        dummyDiv.remove();
+                    }
+                }
+            }
+            else if (w == null || h == null) {
+                // calculate y label dimensions
+                for (i = 0; i < ticks.length; ++i) {
+                    l = ticks[i].label;
+                    if (l)
+                        labels.push('<div class="tickLabel">' + l + '</div>');
+                }
+                
+                if (labels.length > 0) {
+                    dummyDiv = makeDummyDiv(labels, "");
+                    if (w == null)
+                        w = dummyDiv.children().width();
+                    if (h == null)
+                        h = dummyDiv.find("div.tickLabel").height();
+                    dummyDiv.remove();
+                }
+            }
+
+            if (w == null)
+                w = 0;
+            if (h == null)
+                h = 0;
+
+            axis.labelWidth = w;
+            axis.labelHeight = h;
+        }
+
+        function allocateAxisBoxFirstPhase(axis) {
+            // find the bounding box of the axis by looking at label
+            // widths/heights and ticks, make room by diminishing the
+            // plotOffset
+
+            var lw = axis.labelWidth,
+                lh = axis.labelHeight,
+                pos = axis.options.position,
+                tickLength = axis.options.tickLength,
+                axismargin = options.grid.axisMargin,
+                padding = options.grid.labelMargin,
+                all = axis.direction == "x" ? xaxes : yaxes,
+                index;
+
+            // determine axis margin
+            var samePosition = $.grep(all, function (a) {
+                return a && a.options.position == pos && a.reserveSpace;
+            });
+            if ($.inArray(axis, samePosition) == samePosition.length - 1)
+                axismargin = 0; // outermost
+
+            // determine tick length - if we're innermost, we can use "full"
+            if (tickLength == null)
+                tickLength = "full";
+
+            var sameDirection = $.grep(all, function (a) {
+                return a && a.reserveSpace;
+            });
+
+            var innermost = $.inArray(axis, sameDirection) == 0;
+            if (!innermost && tickLength == "full")
+                tickLength = 5;
+                
+            if (!isNaN(+tickLength))
+                padding += +tickLength;
+
+            // compute box
+            if (axis.direction == "x") {
+                lh += padding;
+                
+                if (pos == "bottom") {
+                    plotOffset.bottom += lh + axismargin;
+                    axis.box = { top: canvasHeight - plotOffset.bottom, height: lh };
+                }
+                else {
+                    axis.box = { top: plotOffset.top + axismargin, height: lh };
+                    plotOffset.top += lh + axismargin;
+                }
+            }
+            else {
+                lw += padding;
+                
+                if (pos == "left") {
+                    axis.box = { left: plotOffset.left + axismargin, width: lw };
+                    plotOffset.left += lw + axismargin;
+                }
+                else {
+                    plotOffset.right += lw + axismargin;
+                    axis.box = { left: canvasWidth - plotOffset.right, width: lw };
+                }
+            }
+
+             // save for future reference
+            axis.position = pos;
+            axis.tickLength = tickLength;
+            axis.box.padding = padding;
+            axis.innermost = innermost;
+        }
+
+        function allocateAxisBoxSecondPhase(axis) {
+            // set remaining bounding box coordinates
+            if (axis.direction == "x") {
+                axis.box.left = plotOffset.left;
+                axis.box.width = plotWidth;
+            }
+            else {
+                axis.box.top = plotOffset.top;
+                axis.box.height = plotHeight;
+            }
+        }
+        
+        function setupGrid() {
+            var i, axes = allAxes();
+
+            // first calculate the plot and axis box dimensions
+
+            $.each(axes, function (_, axis) {
+                axis.show = axis.options.show;
+                if (axis.show == null)
+                    axis.show = axis.used; // by default an axis is visible if it's got data
+                
+                axis.reserveSpace = axis.show || axis.options.reserveSpace;
+
+                setRange(axis);
+            });
+
+            allocatedAxes = $.grep(axes, function (axis) { return axis.reserveSpace; });
+
+            plotOffset.left = plotOffset.right = plotOffset.top = plotOffset.bottom = 0;
+            if (options.grid.show) {
+                $.each(allocatedAxes, function (_, axis) {
+                    // make the ticks
+                    setupTickGeneration(axis);
+                    setTicks(axis);
+                    snapRangeToTicks(axis, axis.ticks);
+
+                    // find labelWidth/Height for axis
+                    measureTickLabels(axis);
+                });
+
+                // with all dimensions in house, we can compute the
+                // axis boxes, start from the outside (reverse order)
+                for (i = allocatedAxes.length - 1; i >= 0; --i)
+                    allocateAxisBoxFirstPhase(allocatedAxes[i]);
+
+                // make sure we've got enough space for things that
+                // might stick out
+                var minMargin = options.grid.minBorderMargin;
+                if (minMargin == null) {
+                    minMargin = 0;
+                    for (i = 0; i < series.length; ++i)
+                        minMargin = Math.max(minMargin, series[i].points.radius + series[i].points.lineWidth/2);
+                }
+                    
+                for (var a in plotOffset) {
+                    plotOffset[a] += options.grid.borderWidth;
+                    plotOffset[a] = Math.max(minMargin, plotOffset[a]);
+                }
+            }
+            
+            plotWidth = canvasWidth - plotOffset.left - plotOffset.right;
+            plotHeight = canvasHeight - plotOffset.bottom - plotOffset.top;
+
+            // now we got the proper plotWidth/Height, we can compute the scaling
+            $.each(axes, function (_, axis) {
+                setTransformationHelpers(axis);
+            });
+
+            if (options.grid.show) {
+                $.each(allocatedAxes, function (_, axis) {
+                    allocateAxisBoxSecondPhase(axis);
+                });
+
+                insertAxisLabels();
+            }
+            
+            insertLegend();
+        }
+        
+        function setRange(axis) {
+            var opts = axis.options,
+                min = +(opts.min != null ? opts.min : axis.datamin),
+                max = +(opts.max != null ? opts.max : axis.datamax),
+                delta = max - min;
+
+            if (delta == 0.0) {
+                // degenerate case
+                var widen = max == 0 ? 1 : 0.01;
+
+                if (opts.min == null)
+                    min -= widen;
+                // always widen max if we couldn't widen min to ensure we
+                // don't fall into min == max which doesn't work
+                if (opts.max == null || opts.min != null)
+                    max += widen;
+            }
+            else {
+                // consider autoscaling
+                var margin = opts.autoscaleMargin;
+                if (margin != null) {
+                    if (opts.min == null) {
+                        min -= delta * margin;
+                        // make sure we don't go below zero if all values
+                        // are positive
+                        if (min < 0 && axis.datamin != null && axis.datamin >= 0)
+                            min = 0;
+                    }
+                    if (opts.max == null) {
+                        max += delta * margin;
+                        if (max > 0 && axis.datamax != null && axis.datamax <= 0)
+                            max = 0;
+                    }
+                }
+            }
+            axis.min = min;
+            axis.max = max;
+        }
+
+        function setupTickGeneration(axis) {
+            var opts = axis.options;
+                
+            // estimate number of ticks
+            var noTicks;
+            if (typeof opts.ticks == "number" && opts.ticks > 0)
+                noTicks = opts.ticks;
+            else
+                // heuristic based on the model a*sqrt(x) fitted to
+                // some data points that seemed reasonable
+                noTicks = 0.3 * Math.sqrt(axis.direction == "x" ? canvasWidth : canvasHeight);
+
+            var delta = (axis.max - axis.min) / noTicks,
+                size, generator, unit, formatter, i, magn, norm;
+
+            if (opts.mode == "time") {
+                // pretty handling of time
+                
+                // map of app. size of time units in milliseconds
+                var timeUnitSize = {
+                    "second": 1000,
+                    "minute": 60 * 1000,
+                    "hour": 60 * 60 * 1000,
+                    "day": 24 * 60 * 60 * 1000,
+                    "month": 30 * 24 * 60 * 60 * 1000,
+                    "year": 365.2425 * 24 * 60 * 60 * 1000
+                };
+
+
+                // the allowed tick sizes, after 1 year we use
+                // an integer algorithm
+                var spec = [
+                    [1, "second"], [2, "second"], [5, "second"], [10, "second"],
+                    [30, "second"], 
+                    [1, "minute"], [2, "minute"], [5, "minute"], [10, "minute"],
+                    [30, "minute"], 
+                    [1, "hour"], [2, "hour"], [4, "hour"],
+                    [8, "hour"], [12, "hour"],
+                    [1, "day"], [2, "day"], [3, "day"],
+                    [0.25, "month"], [0.5, "month"], [1, "month"],
+                    [2, "month"], [3, "month"], [6, "month"],
+                    [1, "year"]
+                ];
+
+                var minSize = 0;
+                if (opts.minTickSize != null) {
+                    if (typeof opts.tickSize == "number")
+                        minSize = opts.tickSize;
+                    else
+                        minSize = opts.minTickSize[0] * timeUnitSize[opts.minTickSize[1]];
+                }
+
+                for (var i = 0; i < spec.length - 1; ++i)
+                    if (delta < (spec[i][0] * timeUnitSize[spec[i][1]]
+                                 + spec[i + 1][0] * timeUnitSize[spec[i + 1][1]]) / 2
+                       && spec[i][0] * timeUnitSize[spec[i][1]] >= minSize)
+                        break;
+                size = spec[i][0];
+                unit = spec[i][1];
+                
+                // special-case the possibility of several years
+                if (unit == "year") {
+                    magn = Math.pow(10, Math.floor(Math.log(delta / timeUnitSize.year) / Math.LN10));
+                    norm = (delta / timeUnitSize.year) / magn;
+                    if (norm < 1.5)
+                        size = 1;
+                    else if (norm < 3)
+                        size = 2;
+                    else if (norm < 7.5)
+                        size = 5;
+                    else
+                        size = 10;
+
+                    size *= magn;
+                }
+
+                axis.tickSize = opts.tickSize || [size, unit];
+                
+                generator = function(axis) {
+                    var ticks = [],
+                        tickSize = axis.tickSize[0], unit = axis.tickSize[1],
+                        d = new Date(axis.min);
+                    
+                    var step = tickSize * timeUnitSize[unit];
+
+                    if (unit == "second")
+                        d.setUTCSeconds(floorInBase(d.getUTCSeconds(), tickSize));
+                    if (unit == "minute")
+                        d.setUTCMinutes(floorInBase(d.getUTCMinutes(), tickSize));
+                    if (unit == "hour")
+                        d.setUTCHours(floorInBase(d.getUTCHours(), tickSize));
+                    if (unit == "month")
+                        d.setUTCMonth(floorInBase(d.getUTCMonth(), tickSize));
+                    if (unit == "year")
+                        d.setUTCFullYear(floorInBase(d.getUTCFullYear(), tickSize));
+                    
+                    // reset smaller components
+                    d.setUTCMilliseconds(0);
+                    if (step >= timeUnitSize.minute)
+                        d.setUTCSeconds(0);
+                    if (step >= timeUnitSize.hour)
+                        d.setUTCMinutes(0);
+                    if (step >= timeUnitSize.day)
+                        d.setUTCHours(0);
+                    if (step >= timeUnitSize.day * 4)
+                        d.setUTCDate(1);
+                    if (step >= timeUnitSize.year)
+                        d.setUTCMonth(0);
+
+
+                    var carry = 0, v = Number.NaN, prev;
+                    do {
+                        prev = v;
+                        v = d.getTime();
+                        ticks.push(v);
+                        if (unit == "month") {
+                            if (tickSize < 1) {
+                                // a bit complicated - we'll divide the month
+                                // up but we need to take care of fractions
+                                // so we don't end up in the middle of a day
+                                d.setUTCDate(1);
+                                var start = d.getTime();
+                                d.setUTCMonth(d.getUTCMonth() + 1);
+                                var end = d.getTime();
+                                d.setTime(v + carry * timeUnitSize.hour + (end - start) * tickSize);
+                                carry = d.getUTCHours();
+                                d.setUTCHours(0);
+                            }
+                            else
+                                d.setUTCMonth(d.getUTCMonth() + tickSize);
+                        }
+                        else if (unit == "year") {
+                            d.setUTCFullYear(d.getUTCFullYear() + tickSize);
+                        }
+                        else
+                            d.setTime(v + step);
+                    } while (v < axis.max && v != prev);
+
+                    return ticks;
+                };
+
+                formatter = function (v, axis) {
+                    var d = new Date(v);
+
+                    // first check global format
+                    if (opts.timeformat != null)
+                        return $.plot.formatDate(d, opts.timeformat, opts.monthNames);
+                    
+                    var t = axis.tickSize[0] * timeUnitSize[axis.tickSize[1]];
+                    var span = axis.max - axis.min;
+                    var suffix = (opts.twelveHourClock) ? " %p" : "";
+                    
+                    if (t < timeUnitSize.minute)
+                        fmt = "%h:%M:%S" + suffix;
+                    else if (t < timeUnitSize.day) {
+                        if (span < 2 * timeUnitSize.day)
+                            fmt = "%h:%M" + suffix;
+                        else
+                            fmt = "%b %d %h:%M" + suffix;
+                    }
+                    else if (t < timeUnitSize.month)
+                        fmt = "%b %d";
+                    else if (t < timeUnitSize.year) {
+                        if (span < timeUnitSize.year)
+                            fmt = "%b";
+                        else
+                            fmt = "%b %y";
+                    }
+                    else
+                        fmt = "%y";
+                    
+                    return $.plot.formatDate(d, fmt, opts.monthNames);
+                };
+            }
+            else {
+                // pretty rounding of base-10 numbers
+                var maxDec = opts.tickDecimals;
+                var dec = -Math.floor(Math.log(delta) / Math.LN10);
+                if (maxDec != null && dec > maxDec)
+                    dec = maxDec;
+
+                magn = Math.pow(10, -dec);
+                norm = delta / magn; // norm is between 1.0 and 10.0
+                
+                if (norm < 1.5)
+                    size = 1;
+                else if (norm < 3) {
+                    size = 2;
+                    // special case for 2.5, requires an extra decimal
+                    if (norm > 2.25 && (maxDec == null || dec + 1 <= maxDec)) {
+                        size = 2.5;
+                        ++dec;
+                    }
+                }
+                else if (norm < 7.5)
+                    size = 5;
+                else
+                    size = 10;
+
+                size *= magn;
+                
+                if (opts.minTickSize != null && size < opts.minTickSize)
+                    size = opts.minTickSize;
+
+                axis.tickDecimals = Math.max(0, maxDec != null ? maxDec : dec);
+                axis.tickSize = opts.tickSize || size;
+
+                generator = function (axis) {
+                    var ticks = [];
+
+                    // spew out all possible ticks
+                    var start = floorInBase(axis.min, axis.tickSize),
+                        i = 0, v = Number.NaN, prev;
+                    do {
+                        prev = v;
+                        v = start + i * axis.tickSize;
+                        ticks.push(v);
+                        ++i;
+                    } while (v < axis.max && v != prev);
+                    return ticks;
+                };
+
+                formatter = function (v, axis) {
+                    return v.toFixed(axis.tickDecimals);
+                };
+            }
+
+            if (opts.alignTicksWithAxis != null) {
+                var otherAxis = (axis.direction == "x" ? xaxes : yaxes)[opts.alignTicksWithAxis - 1];
+                if (otherAxis && otherAxis.used && otherAxis != axis) {
+                    // consider snapping min/max to outermost nice ticks
+                    var niceTicks = generator(axis);
+                    if (niceTicks.length > 0) {
+                        if (opts.min == null)
+                            axis.min = Math.min(axis.min, niceTicks[0]);
+                        if (opts.max == null && niceTicks.length > 1)
+                            axis.max = Math.max(axis.max, niceTicks[niceTicks.length - 1]);
+                    }
+                    
+                    generator = function (axis) {
+                        // copy ticks, scaled to this axis
+                        var ticks = [], v, i;
+                        for (i = 0; i < otherAxis.ticks.length; ++i) {
+                            v = (otherAxis.ticks[i].v - otherAxis.min) / (otherAxis.max - otherAxis.min);
+                            v = axis.min + v * (axis.max - axis.min);
+                            ticks.push(v);
+                        }
+                        return ticks;
+                    };
+                    
+                    // we might need an extra decimal since forced
+                    // ticks don't necessarily fit naturally
+                    if (axis.mode != "time" && opts.tickDecimals == null) {
+                        var extraDec = Math.max(0, -Math.floor(Math.log(delta) / Math.LN10) + 1),
+                            ts = generator(axis);
+
+                        // only proceed if the tick interval rounded
+                        // with an extra decimal doesn't give us a
+                        // zero at end
+                        if (!(ts.length > 1 && /\..*0$/.test((ts[1] - ts[0]).toFixed(extraDec))))
+                            axis.tickDecimals = extraDec;
+                    }
+                }
+            }
+
+            axis.tickGenerator = generator;
+            if ($.isFunction(opts.tickFormatter))
+                axis.tickFormatter = function (v, axis) { return "" + opts.tickFormatter(v, axis); };
+            else
+                axis.tickFormatter = formatter;
+        }
+        
+        function setTicks(axis) {
+            var oticks = axis.options.ticks, ticks = [];
+            if (oticks == null || (typeof oticks == "number" && oticks > 0))
+                ticks = axis.tickGenerator(axis);
+            else if (oticks) {
+                if ($.isFunction(oticks))
+                    // generate the ticks
+                    ticks = oticks({ min: axis.min, max: axis.max });
+                else
+                    ticks = oticks;
+            }
+
+            // clean up/labelify the supplied ticks, copy them over
+            var i, v;
+            axis.ticks = [];
+            for (i = 0; i < ticks.length; ++i) {
+                var label = null;
+                var t = ticks[i];
+                if (typeof t == "object") {
+                    v = +t[0];
+                    if (t.length > 1)
+                        label = t[1];
+                }
+                else
+                    v = +t;
+                if (label == null)
+                    label = axis.tickFormatter(v, axis);
+                if (!isNaN(v))
+                    axis.ticks.push({ v: v, label: label });
+            }
+        }
+
+        function snapRangeToTicks(axis, ticks) {
+            if (axis.options.autoscaleMargin && ticks.length > 0) {
+                // snap to ticks
+                if (axis.options.min == null)
+                    axis.min = Math.min(axis.min, ticks[0].v);
+                if (axis.options.max == null && ticks.length > 1)
+                    axis.max = Math.max(axis.max, ticks[ticks.length - 1].v);
+            }
+        }
+      
+        function draw() {
+            ctx.clearRect(0, 0, canvasWidth, canvasHeight);
+
+            var grid = options.grid;
+
+            // draw background, if any
+            if (grid.show && grid.backgroundColor)
+                drawBackground();
+            
+            if (grid.show && !grid.aboveData)
+                drawGrid();
+
+            for (var i = 0; i < series.length; ++i) {
+                executeHooks(hooks.drawSeries, [ctx, series[i]]);
+                drawSeries(series[i]);
+            }
+
+            executeHooks(hooks.draw, [ctx]);
+            
+            if (grid.show && grid.aboveData)
+                drawGrid();
+        }
+
+        function extractRange(ranges, coord) {
+            var axis, from, to, key, axes = allAxes();
+
+            for (i = 0; i < axes.length; ++i) {
+                axis = axes[i];
+                if (axis.direction == coord) {
+                    key = coord + axis.n + "axis";
+                    if (!ranges[key] && axis.n == 1)
+                        key = coord + "axis"; // support x1axis as xaxis
+                    if (ranges[key]) {
+                        from = ranges[key].from;
+                        to = ranges[key].to;
+                        break;
+                    }
+                }
+            }
+
+            // backwards-compat stuff - to be removed in future
+            if (!ranges[key]) {
+                axis = coord == "x" ? xaxes[0] : yaxes[0];
+                from = ranges[coord + "1"];
+                to = ranges[coord + "2"];
+            }
+
+            // auto-reverse as an added bonus
+            if (from != null && to != null && from > to) {
+                var tmp = from;
+                from = to;
+                to = tmp;
+            }
+            
+            return { from: from, to: to, axis: axis };
+        }
+        
+        function drawBackground() {
+            ctx.save();
+            ctx.translate(plotOffset.left, plotOffset.top);
+
+            ctx.fillStyle = getColorOrGradient(options.grid.backgroundColor, plotHeight, 0, "rgba(255, 255, 255, 0)");
+            ctx.fillRect(0, 0, plotWidth, plotHeight);
+            ctx.restore();
+        }
+
+        function drawGrid() {
+            var i;
+            
+            ctx.save();
+            ctx.translate(plotOffset.left, plotOffset.top);
+
+            // draw markings
+            var markings = options.grid.markings;
+            if (markings) {
+                if ($.isFunction(markings)) {
+                    var axes = plot.getAxes();
+                    // xmin etc. is backwards compatibility, to be
+                    // removed in the future
+                    axes.xmin = axes.xaxis.min;
+                    axes.xmax = axes.xaxis.max;
+                    axes.ymin = axes.yaxis.min;
+                    axes.ymax = axes.yaxis.max;
+                    
+                    markings = markings(axes);
+                }
+
+                for (i = 0; i < markings.length; ++i) {
+                    var m = markings[i],
+                        xrange = extractRange(m, "x"),
+                        yrange = extractRange(m, "y");
+
+                    // fill in missing
+                    if (xrange.from == null)
+                        xrange.from = xrange.axis.min;
+                    if (xrange.to == null)
+                        xrange.to = xrange.axis.max;
+                    if (yrange.from == null)
+                        yrange.from = yrange.axis.min;
+                    if (yrange.to == null)
+                        yrange.to = yrange.axis.max;
+
+                    // clip
+                    if (xrange.to < xrange.axis.min || xrange.from > xrange.axis.max ||
+                        yrange.to < yrange.axis.min || yrange.from > yrange.axis.max)
+                        continue;
+
+                    xrange.from = Math.max(xrange.from, xrange.axis.min);
+                    xrange.to = Math.min(xrange.to, xrange.axis.max);
+                    yrange.from = Math.max(yrange.from, yrange.axis.min);
+                    yrange.to = Math.min(yrange.to, yrange.axis.max);
+
+                    if (xrange.from == xrange.to && yrange.from == yrange.to)
+                        continue;
+
+                    // then draw
+                    xrange.from = xrange.axis.p2c(xrange.from);
+                    xrange.to = xrange.axis.p2c(xrange.to);
+                    yrange.from = yrange.axis.p2c(yrange.from);
+                    yrange.to = yrange.axis.p2c(yrange.to);
+                    
+                    if (xrange.from == xrange.to || yrange.from == yrange.to) {
+                        // draw line
+                        ctx.beginPath();
+                        ctx.strokeStyle = m.color || options.grid.markingsColor;
+                        ctx.lineWidth = m.lineWidth || options.grid.markingsLineWidth;
+                        ctx.moveTo(xrange.from, yrange.from);
+                        ctx.lineTo(xrange.to, yrange.to);
+                        ctx.stroke();
+                    }
+                    else {
+                        // fill area
+                        ctx.fillStyle = m.color || options.grid.markingsColor;
+                        ctx.fillRect(xrange.from, yrange.to,
+                                     xrange.to - xrange.from,
+                                     yrange.from - yrange.to);
+                    }
+                }
+            }
+            
+            // draw the ticks
+            var axes = allAxes(), bw = options.grid.borderWidth;
+
+            for (var j = 0; j < axes.length; ++j) {
+                var axis = axes[j], box = axis.box,
+                    t = axis.tickLength, x, y, xoff, yoff;
+                if (!axis.show || axis.ticks.length == 0)
+                    continue
+                
+                ctx.strokeStyle = axis.options.tickColor || $.color.parse(axis.options.color).scale('a', 0.22).toString();
+                ctx.lineWidth = 1;
+
+                // find the edges
+                if (axis.direction == "x") {
+                    x = 0;
+                    if (t == "full")
+                        y = (axis.position == "top" ? 0 : plotHeight);
+                    else
+                        y = box.top - plotOffset.top + (axis.position == "top" ? box.height : 0);
+                }
+                else {
+                    y = 0;
+                    if (t == "full")
+                        x = (axis.position == "left" ? 0 : plotWidth);
+                    else
+                        x = box.left - plotOffset.left + (axis.position == "left" ? box.width : 0);
+                }
+                
+                // draw tick bar
+                if (!axis.innermost) {
+                    ctx.beginPath();
+                    xoff = yoff = 0;
+                    if (axis.direction == "x")
+                        xoff = plotWidth;
+                    else
+                        yoff = plotHeight;
+                    
+                    if (ctx.lineWidth == 1) {
+                        x = Math.floor(x) + 0.5;
+                        y = Math.floor(y) + 0.5;
+                    }
+
+                    ctx.moveTo(x, y);
+                    ctx.lineTo(x + xoff, y + yoff);
+                    ctx.stroke();
+                }
+
+                // draw ticks
+                ctx.beginPath();
+                for (i = 0; i < axis.ticks.length; ++i) {
+                    var v = axis.ticks[i].v;
+                    
+                    xoff = yoff = 0;
+
+                    if (v < axis.min || v > axis.max
+                        // skip those lying on the axes if we got a border
+                        || (t == "full" && bw > 0
+                            && (v == axis.min || v == axis.max)))
+                        continue;
+
+                    if (axis.direction == "x") {
+                        x = axis.p2c(v);
+                        yoff = t == "full" ? -plotHeight : t;
+                        
+                        if (axis.position == "top")
+                            yoff = -yoff;
+                    }
+                    else {
+                        y = axis.p2c(v);
+                        xoff = t == "full" ? -plotWidth : t;
+                        
+                        if (axis.position == "left")
+                            xoff = -xoff;
+                    }
+
+                    if (ctx.lineWidth == 1) {
+                        if (axis.direction == "x")
+                            x = Math.floor(x) + 0.5;
+                        else
+                            y = Math.floor(y) + 0.5;
+                    }
+
+                    ctx.moveTo(x, y);
+                    ctx.lineTo(x + xoff, y + yoff);
+                }
+                
+                ctx.stroke();
+            }
+            
+            
+            // draw border
+            if (bw) {
+                ctx.lineWidth = bw;
+                ctx.strokeStyle = options.grid.borderColor;
+                ctx.strokeRect(-bw/2, -bw/2, plotWidth + bw, plotHeight + bw);
+            }
+
+            ctx.restore();
+        }
+
+        function insertAxisLabels() {
+            placeholder.find(".tickLabels").remove();
+            
+            var html = ['<div class="tickLabels" style="font-size:smaller">'];
+
+            var axes = allAxes();
+            for (var j = 0; j < axes.length; ++j) {
+                var axis = axes[j], box = axis.box;
+                if (!axis.show)
+                    continue;
+                //debug: html.push('<div style="position:absolute;opacity:0.10;background-color:red;left:' + box.left + 'px;top:' + box.top + 'px;width:' + box.width +  'px;height:' + box.height + 'px"></div>')
+                html.push('<div class="' + axis.direction + 'Axis ' + axis.direction + axis.n + 'Axis" style="color:' + axis.options.color + '">');
+                for (var i = 0; i < axis.ticks.length; ++i) {
+                    var tick = axis.ticks[i];
+                    if (!tick.label || tick.v < axis.min || tick.v > axis.max)
+                        continue;
+
+                    var pos = {}, align;
+                    
+                    if (axis.direction == "x") {
+                        align = "center";
+                        pos.left = Math.round(plotOffset.left + axis.p2c(tick.v) - axis.labelWidth/2);
+                        if (axis.position == "bottom")
+                            pos.top = box.top + box.padding;
+                        else
+                            pos.bottom = canvasHeight - (box.top + box.height - box.padding);
+                    }
+                    else {
+                        pos.top = Math.round(plotOffset.top + axis.p2c(tick.v) - axis.labelHeight/2);
+                        if (axis.position == "left") {
+                            pos.right = canvasWidth - (box.left + box.width - box.padding)
+                            align = "right";
+                        }
+                        else {
+                            pos.left = box.left + box.padding;
+                            align = "left";
+                        }
+                    }
+
+                    pos.width = axis.labelWidth;
+
+                    var style = ["position:absolute", "text-align:" + align ];
+                    for (var a in pos)
+                        style.push(a + ":" + pos[a] + "px")
+                    
+                    html.push('<div class="tickLabel" style="' + style.join(';') + '">' + tick.label + '</div>');
+                }
+                html.push('</div>');
+            }
+
+            html.push('</div>');
+
+            placeholder.append(html.join(""));
+        }
+
+        function drawSeries(series) {
+            if (series.lines.show)
+                drawSeriesLines(series);
+            if (series.bars.show)
+                drawSeriesBars(series);
+            if (series.points.show)
+                drawSeriesPoints(series);
+        }
+        
+        function drawSeriesLines(series) {
+            function plotLine(datapoints, xoffset, yoffset, axisx, axisy) {
+                var points = datapoints.points,
+                    ps = datapoints.pointsize,
+                    prevx = null, prevy = null;
+                
+                ctx.beginPath();
+                for (var i = ps; i < points.length; i += ps) {
+                    var x1 = points[i - ps], y1 = points[i - ps + 1],
+                        x2 = points[i], y2 = points[i + 1];
+                    
+                    if (x1 == null || x2 == null)
+                        continue;
+
+                    // clip with ymin
+                    if (y1 <= y2 && y1 < axisy.min) {
+                        if (y2 < axisy.min)
+                            continue;   // line segment is outside
+                        // compute new intersection point
+                        x1 = (axisy.min - y1) / (y2 - y1) * (x2 - x1) + x1;
+                        y1 = axisy.min;
+                    }
+                    else if (y2 <= y1 && y2 < axisy.min) {
+                        if (y1 < axisy.min)
+                            continue;
+                        x2 = (axisy.min - y1) / (y2 - y1) * (x2 - x1) + x1;
+                        y2 = axisy.min;
+                    }
+
+                    // clip with ymax
+                    if (y1 >= y2 && y1 > axisy.max) {
+                        if (y2 > axisy.max)
+                            continue;
+                        x1 = (axisy.max - y1) / (y2 - y1) * (x2 - x1) + x1;
+                        y1 = axisy.max;
+                    }
+                    else if (y2 >= y1 && y2 > axisy.max) {
+                        if (y1 > axisy.max)
+                            continue;
+                        x2 = (axisy.max - y1) / (y2 - y1) * (x2 - x1) + x1;
+                        y2 = axisy.max;
+                    }
+
+                    // clip with xmin
+                    if (x1 <= x2 && x1 < axisx.min) {
+                        if (x2 < axisx.min)
+                            continue;
+                        y1 = (axisx.min - x1) / (x2 - x1) * (y2 - y1) + y1;
+                        x1 = axisx.min;
+                    }
+                    else if (x2 <= x1 && x2 < axisx.min) {
+                        if (x1 < axisx.min)
+                            continue;
+                        y2 = (axisx.min - x1) / (x2 - x1) * (y2 - y1) + y1;
+                        x2 = axisx.min;
+                    }
+
+                    // clip with xmax
+                    if (x1 >= x2 && x1 > axisx.max) {
+                        if (x2 > axisx.max)
+                            continue;
+                        y1 = (axisx.max - x1) / (x2 - x1) * (y2 - y1) + y1;
+                        x1 = axisx.max;
+                    }
+                    else if (x2 >= x1 && x2 > axisx.max) {
+                        if (x1 > axisx.max)
+                            continue;
+                        y2 = (axisx.max - x1) / (x2 - x1) * (y2 - y1) + y1;
+                        x2 = axisx.max;
+                    }
+
+                    if (x1 != prevx || y1 != prevy)
+                        ctx.moveTo(axisx.p2c(x1) + xoffset, axisy.p2c(y1) + yoffset);
+                    
+                    prevx = x2;
+                    prevy = y2;
+                    ctx.lineTo(axisx.p2c(x2) + xoffset, axisy.p2c(y2) + yoffset);
+                }
+                ctx.stroke();
+            }
+
+            function plotLineArea(datapoints, axisx, axisy) {
+                var points = datapoints.points,
+                    ps = datapoints.pointsize,
+                    bottom = Math.min(Math.max(0, axisy.min), axisy.max),
+                    i = 0, top, areaOpen = false,
+                    ypos = 1, segmentStart = 0, segmentEnd = 0;
+
+                // we process each segment in two turns, first forward
+                // direction to sketch out top, then once we hit the
+                // end we go backwards to sketch the bottom
+                while (true) {
+                    if (ps > 0 && i > points.length + ps)
+                        break;
+
+                    i += ps; // ps is negative if going backwards
+
+                    var x1 = points[i - ps],
+                        y1 = points[i - ps + ypos],
+                        x2 = points[i], y2 = points[i + ypos];
+
+                    if (areaOpen) {
+                        if (ps > 0 && x1 != null && x2 == null) {
+                            // at turning point
+                            segmentEnd = i;
+                            ps = -ps;
+                            ypos = 2;
+                            continue;
+                        }
+
+                        if (ps < 0 && i == segmentStart + ps) {
+                            // done with the reverse sweep
+                            ctx.fill();
+                            areaOpen = false;
+                            ps = -ps;
+                            ypos = 1;
+                            i = segmentStart = segmentEnd + ps;
+                            continue;
+                        }
+                    }
+
+                    if (x1 == null || x2 == null)
+                        continue;
+
+                    // clip x values
+                    
+                    // clip with xmin
+                    if (x1 <= x2 && x1 < axisx.min) {
+                        if (x2 < axisx.min)
+                            continue;
+                        y1 = (axisx.min - x1) / (x2 - x1) * (y2 - y1) + y1;
+                        x1 = axisx.min;
+                    }
+                    else if (x2 <= x1 && x2 < axisx.min) {
+                        if (x1 < axisx.min)
+                            continue;
+                        y2 = (axisx.min - x1) / (x2 - x1) * (y2 - y1) + y1;
+                        x2 = axisx.min;
+                    }
+
+                    // clip with xmax
+                    if (x1 >= x2 && x1 > axisx.max) {
+                        if (x2 > axisx.max)
+                            continue;
+                        y1 = (axisx.max - x1) / (x2 - x1) * (y2 - y1) + y1;
+                        x1 = axisx.max;
+                    }
+                    else if (x2 >= x1 && x2 > axisx.max) {
+                        if (x1 > axisx.max)
+                            continue;
+                        y2 = (axisx.max - x1) / (x2 - x1) * (y2 - y1) + y1;
+                        x2 = axisx.max;
+                    }
+
+                    if (!areaOpen) {
+                        // open area
+                        ctx.beginPath();
+                        ctx.moveTo(axisx.p2c(x1), axisy.p2c(bottom));
+                        areaOpen = true;
+                    }
+                    
+                    // now first check the case where both is outside
+                    if (y1 >= axisy.max && y2 >= axisy.max) {
+                        ctx.lineTo(axisx.p2c(x1), axisy.p2c(axisy.max));
+                        ctx.lineTo(axisx.p2c(x2), axisy.p2c(axisy.max));
+                        continue;
+                    }
+                    else if (y1 <= axisy.min && y2 <= axisy.min) {
+                        ctx.lineTo(axisx.p2c(x1), axisy.p2c(axisy.min));
+                        ctx.lineTo(axisx.p2c(x2), axisy.p2c(axisy.min));
+                        continue;
+                    }
+                    
+                    // else it's a bit more complicated, there might
+                    // be a flat maxed out rectangle first, then a
+                    // triangular cutout or reverse; to find these
+                    // keep track of the current x values
+                    var x1old = x1, x2old = x2;
+
+                    // clip the y values, without shortcutting, we
+                    // go through all cases in turn
+                    
+                    // clip with ymin
+                    if (y1 <= y2 && y1 < axisy.min && y2 >= axisy.min) {
+                        x1 = (axisy.min - y1) / (y2 - y1) * (x2 - x1) + x1;
+                        y1 = axisy.min;
+                    }
+                    else if (y2 <= y1 && y2 < axisy.min && y1 >= axisy.min) {
+                        x2 = (axisy.min - y1) / (y2 - y1) * (x2 - x1) + x1;
+                        y2 = axisy.min;
+                    }
+
+                    // clip with ymax
+                    if (y1 >= y2 && y1 > axisy.max && y2 <= axisy.max) {
+                        x1 = (axisy.max - y1) / (y2 - y1) * (x2 - x1) + x1;
+                        y1 = axisy.max;
+                    }
+                    else if (y2 >= y1 && y2 > axisy.max && y1 <= axisy.max) {
+                        x2 = (axisy.max - y1) / (y2 - y1) * (x2 - x1) + x1;
+                        y2 = axisy.max;
+                    }
+
+                    // if the x value was changed we got a rectangle
+                    // to fill
+                    if (x1 != x1old) {
+                        ctx.lineTo(axisx.p2c(x1old), axisy.p2c(y1));
+                        // it goes to (x1, y1), but we fill that below
+                    }
+                    
+                    // fill triangular section, this sometimes result
+                    // in redundant points if (x1, y1) hasn't changed
+                    // from previous line to, but we just ignore that
+                    ctx.lineTo(axisx.p2c(x1), axisy.p2c(y1));
+                    ctx.lineTo(axisx.p2c(x2), axisy.p2c(y2));
+
+                    // fill the other rectangle if it's there
+                    if (x2 != x2old) {
+                        ctx.lineTo(axisx.p2c(x2), axisy.p2c(y2));
+                        ctx.lineTo(axisx.p2c(x2old), axisy.p2c(y2));
+                    }
+                }
+            }
+
+            ctx.save();
+            ctx.translate(plotOffset.left, plotOffset.top);
+            ctx.lineJoin = "round";
+
+            var lw = series.lines.lineWidth,
+                sw = series.shadowSize;
+            // FIXME: consider another form of shadow when filling is turned on
+            if (lw > 0 && sw > 0) {
+                // draw shadow as a thick and thin line with transparency
+                ctx.lineWidth = sw;
+                ctx.strokeStyle = "rgba(0,0,0,0.1)";
+                // position shadow at angle from the mid of line
+                var angle = Math.PI/18;
+                plotLine(series.datapoints, Math.sin(angle) * (lw/2 + sw/2), Math.cos(angle) * (lw/2 + sw/2), series.xaxis, series.yaxis);
+                ctx.lineWidth = sw/2;
+                plotLine(series.datapoints, Math.sin(angle) * (lw/2 + sw/4), Math.cos(angle) * (lw/2 + sw/4), series.xaxis, series.yaxis);
+            }
+
+            ctx.lineWidth = lw;
+            ctx.strokeStyle = series.color;
+            var fillStyle = getFillStyle(series.lines, series.color, 0, plotHeight);
+            if (fillStyle) {
+                ctx.fillStyle = fillStyle;
+                plotLineArea(series.datapoints, series.xaxis, series.yaxis);
+            }
+
+            if (lw > 0)
+                plotLine(series.datapoints, 0, 0, series.xaxis, series.yaxis);
+            ctx.restore();
+        }
+
+        function drawSeriesPoints(series) {
+            function plotPoints(datapoints, radius, fillStyle, offset, shadow, axisx, axisy, symbol) {
+                var points = datapoints.points, ps = datapoints.pointsize;
+
+                for (var i = 0; i < points.length; i += ps) {
+                    var x = points[i], y = points[i + 1];
+                    if (x == null || x < axisx.min || x > axisx.max || y < axisy.min || y > axisy.max)
+                        continue;
+                    
+                    ctx.beginPath();
+                    x = axisx.p2c(x);
+                    y = axisy.p2c(y) + offset;
+                    if (symbol == "circle")
+                        ctx.arc(x, y, radius, 0, shadow ? Math.PI : Math.PI * 2, false);
+                    else
+                        symbol(ctx, x, y, radius, shadow);
+                    ctx.closePath();
+                    
+                    if (fillStyle) {
+                        ctx.fillStyle = fillStyle;
+                        ctx.fill();
+                    }
+                    ctx.stroke();
+                }
+            }
+            
+            ctx.save();
+            ctx.translate(plotOffset.left, plotOffset.top);
+
+            var lw = series.points.lineWidth,
+                sw = series.shadowSize,
+                radius = series.points.radius,
+                symbol = series.points.symbol;
+            if (lw > 0 && sw > 0) {
+                // draw shadow in two steps
+                var w = sw / 2;
+                ctx.lineWidth = w;
+                ctx.strokeStyle = "rgba(0,0,0,0.1)";
+                plotPoints(series.datapoints, radius, null, w + w/2, true,
+                           series.xaxis, series.yaxis, symbol);
+
+                ctx.strokeStyle = "rgba(0,0,0,0.2)";
+                plotPoints(series.datapoints, radius, null, w/2, true,
+                           series.xaxis, series.yaxis, symbol);
+            }
+
+            ctx.lineWidth = lw;
+            ctx.strokeStyle = series.color;
+            plotPoints(series.datapoints, radius,
+                       getFillStyle(series.points, series.color), 0, false,
+                       series.xaxis, series.yaxis, symbol);
+            ctx.restore();
+        }
+
+        function drawBar(x, y, b, barLeft, barRight, offset, fillStyleCallback, axisx, axisy, c, horizontal, lineWidth) {
+            var left, right, bottom, top,
+                drawLeft, drawRight, drawTop, drawBottom,
+                tmp;
+
+            // in horizontal mode, we start the bar from the left
+            // instead of from the bottom so it appears to be
+            // horizontal rather than vertical
+            if (horizontal) {
+                drawBottom = drawRight = drawTop = true;
+                drawLeft = false;
+                left = b;
+                right = x;
+                top = y + barLeft;
+                bottom = y + barRight;
+
+                // account for negative bars
+                if (right < left) {
+                    tmp = right;
+                    right = left;
+                    left = tmp;
+                    drawLeft = true;
+                    drawRight = false;
+                }
+            }
+            else {
+                drawLeft = drawRight = drawTop = true;
+                drawBottom = false;
+                left = x + barLeft;
+                right = x + barRight;
+                bottom = b;
+                top = y;
+
+                // account for negative bars
+                if (top < bottom) {
+                    tmp = top;
+                    top = bottom;
+                    bottom = tmp;
+                    drawBottom = true;
+                    drawTop = false;
+                }
+            }
+           
+            // clip
+            if (right < axisx.min || left > axisx.max ||
+                top < axisy.min || bottom > axisy.max)
+                return;
+            
+            if (left < axisx.min) {
+                left = axisx.min;
+                drawLeft = false;
+            }
+
+            if (right > axisx.max) {
+                right = axisx.max;
+                drawRight = false;
+            }
+
+            if (bottom < axisy.min) {
+                bottom = axisy.min;
+                drawBottom = false;
+            }
+            
+            if (top > axisy.max) {
+                top = axisy.max;
+                drawTop = false;
+            }
+
+            left = axisx.p2c(left);
+            bottom = axisy.p2c(bottom);
+            right = axisx.p2c(right);
+            top = axisy.p2c(top);
+            
+            // fill the bar
+            if (fillStyleCallback) {
+                c.beginPath();
+                c.moveTo(left, bottom);
+                c.lineTo(left, top);
+                c.lineTo(right, top);
+                c.lineTo(right, bottom);
+                c.fillStyle = fillStyleCallback(bottom, top);
+                c.fill();
+            }
+
+            // draw outline
+            if (lineWidth > 0 && (drawLeft || drawRight || drawTop || drawBottom)) {
+                c.beginPath();
+
+                // FIXME: inline moveTo is buggy with excanvas
+                c.moveTo(left, bottom + offset);
+                if (drawLeft)
+                    c.lineTo(left, top + offset);
+                else
+                    c.moveTo(left, top + offset);
+                if (drawTop)
+                    c.lineTo(right, top + offset);
+                else
+                    c.moveTo(right, top + offset);
+                if (drawRight)
+                    c.lineTo(right, bottom + offset);
+                else
+                    c.moveTo(right, bottom + offset);
+                if (drawBottom)
+                    c.lineTo(left, bottom + offset);
+                else
+                    c.moveTo(left, bottom + offset);
+                c.stroke();
+            }
+        }
+        
+        function drawSeriesBars(series) {
+            function plotBars(datapoints, barLeft, barRight, offset, fillStyleCallback, axisx, axisy) {
+                var points = datapoints.points, ps = datapoints.pointsize;
+                
+                for (var i = 0; i < points.length; i += ps) {
+                    if (points[i] == null)
+                        continue;
+                    drawBar(points[i], points[i + 1], points[i + 2], barLeft, barRight, offset, fillStyleCallback, axisx, axisy, ctx, series.bars.horizontal, series.bars.lineWidth);
+                }
+            }
+
+            ctx.save();
+            ctx.translate(plotOffset.left, plotOffset.top);
+
+            // FIXME: figure out a way to add shadows (for instance along the right edge)
+            ctx.lineWidth = series.bars.lineWidth;
+            ctx.strokeStyle = series.color;
+            var barLeft = series.bars.align == "left" ? 0 : -series.bars.barWidth/2;
+            var fillStyleCallback = series.bars.fill ? function (bottom, top) { return getFillStyle(series.bars, series.color, bottom, top); } : null;
+            plotBars(series.datapoints, barLeft, barLeft + series.bars.barWidth, 0, fillStyleCallback, series.xaxis, series.yaxis);
+            ctx.restore();
+        }
+
+        function getFillStyle(filloptions, seriesColor, bottom, top) {
+            var fill = filloptions.fill;
+            if (!fill)
+                return null;
+
+            if (filloptions.fillColor)
+                return getColorOrGradient(filloptions.fillColor, bottom, top, seriesColor);
+            
+            var c = $.color.parse(seriesColor);
+            c.a = typeof fill == "number" ? fill : 0.4;
+            c.normalize();
+            return c.toString();
+        }
+        
+        function insertLegend() {
+            placeholder.find(".legend").remove();
+
+            if (!options.legend.show)
+                return;
+            
+            var fragments = [], rowStarted = false,
+                lf = options.legend.labelFormatter, s, label;
+            for (var i = 0; i < series.length; ++i) {
+                s = series[i];
+                label = s.label;
+                if (!label)
+                    continue;
+                
+                if (i % options.legend.noColumns == 0) {
+                    if (rowStarted)
+                        fragments.push('</tr>');
+                    fragments.push('<tr>');
+                    rowStarted = true;
+                }
+
+                if (lf)
+                    label = lf(label, s);
+                
+                fragments.push(
+                    '<td class="legendColorBox"><div style="border:1px solid ' + options.legend.labelBoxBorderColor + ';padding:1px"><div style="width:4px;height:0;border:5px solid ' + s.color + ';overflow:hidden"></div></div></td>' +
+                    '<td class="legendLabel">' + label + '</td>');
+            }
+            if (rowStarted)
+                fragments.push('</tr>');
+            
+            if (fragments.length == 0)
+                return;
+
+            var table = '<table style="font-size:smaller;color:' + options.grid.color + '">' + fragments.join("") + '</table>';
+            if (options.legend.container != null)
+                $(options.legend.container).html(table);
+            else {
+                var pos = "",
+                    p = options.legend.position,
+                    m = options.legend.margin;
+                if (m[0] == null)
+                    m = [m, m];
+                if (p.charAt(0) == "n")
+                    pos += 'top:' + (m[1] + plotOffset.top) + 'px;';
+                else if (p.charAt(0) == "s")
+                    pos += 'bottom:' + (m[1] + plotOffset.bottom) + 'px;';
+                if (p.charAt(1) == "e")
+                    pos += 'right:' + (m[0] + plotOffset.right) + 'px;';
+                else if (p.charAt(1) == "w")
+                    pos += 'left:' + (m[0] + plotOffset.left) + 'px;';
+                var legend = $('<div class="legend">' + table.replace('style="', 'style="position:absolute;' + pos +';') + '</div>').appendTo(placeholder);
+                if (options.legend.backgroundOpacity != 0.0) {
+                    // put in the transparent background
+                    // separately to avoid blended labels and
+                    // label boxes
+                    var c = options.legend.backgroundColor;
+                    if (c == null) {
+                        c = options.grid.backgroundColor;
+                        if (c && typeof c == "string")
+                            c = $.color.parse(c);
+                        else
+                            c = $.color.extract(legend, 'background-color');
+                        c.a = 1;
+                        c = c.toString();
+                    }
+                    var div = legend.children();
+                    $('<div style="position:absolute;width:' + div.width() + 'px;height:' + div.height() + 'px;' + pos +'background-color:' + c + ';"> </div>').prependTo(legend).css('opacity', options.legend.backgroundOpacity);
+                }
+            }
+        }
+
+
+        // interactive features
+        
+        var highlights = [],
+            redrawTimeout = null;
+        
+        // returns the data item the mouse is over, or null if none is found
+        function findNearbyItem(mouseX, mouseY, seriesFilter) {
+            var maxDistance = options.grid.mouseActiveRadius,
+                smallestDistance = maxDistance * maxDistance + 1,
+                item = null, foundPoint = false, i, j;
+
+            for (i = series.length - 1; i >= 0; --i) {
+                if (!seriesFilter(series[i]))
+                    continue;
+                
+                var s = series[i],
+                    axisx = s.xaxis,
+                    axisy = s.yaxis,
+                    points = s.datapoints.points,
+                    ps = s.datapoints.pointsize,
+                    mx = axisx.c2p(mouseX), // precompute some stuff to make the loop faster
+                    my = axisy.c2p(mouseY),
+                    maxx = maxDistance / axisx.scale,
+                    maxy = maxDistance / axisy.scale;
+
+                // with inverse transforms, we can't use the maxx/maxy
+                // optimization, sadly
+                if (axisx.options.inverseTransform)
+                    maxx = Number.MAX_VALUE;
+                if (axisy.options.inverseTransform)
+                    maxy = Number.MAX_VALUE;
+                
+                if (s.lines.show || s.points.show) {
+                    for (j = 0; j < points.length; j += ps) {
+                        var x = points[j], y = points[j + 1];
+                        if (x == null)
+                            continue;
+                        
+                        // For points and lines, the cursor must be within a
+                        // certain distance to the data point
+                        if (x - mx > maxx || x - mx < -maxx ||
+                            y - my > maxy || y - my < -maxy)
+                            continue;
+
+                        // We have to calculate distances in pixels, not in
+                        // data units, because the scales of the axes may be different
+                        var dx = Math.abs(axisx.p2c(x) - mouseX),
+                            dy = Math.abs(axisy.p2c(y) - mouseY),
+                            dist = dx * dx + dy * dy; // we save the sqrt
+
+                        // use <= to ensure last point takes precedence
+                        // (last generally means on top of)
+                        if (dist < smallestDistance) {
+                            smallestDistance = dist;
+                            item = [i, j / ps];
+                        }
+                    }
+                }
+                    
+                if (s.bars.show && !item) { // no other point can be nearby
+                    var barLeft = s.bars.align == "left" ? 0 : -s.bars.barWidth/2,
+                        barRight = barLeft + s.bars.barWidth;
+                    
+                    for (j = 0; j < points.length; j += ps) {
+                        var x = points[j], y = points[j + 1], b = points[j + 2];
+                        if (x == null)
+                            continue;
+  
+                        // for a bar graph, the cursor must be inside the bar
+                        if (series[i].bars.horizontal ? 
+                            (mx <= Math.max(b, x) && mx >= Math.min(b, x) && 
+                             my >= y + barLeft && my <= y + barRight) :
+                            (mx >= x + barLeft && mx <= x + barRight &&
+                             my >= Math.min(b, y) && my <= Math.max(b, y)))
+                                item = [i, j / ps];
+                    }
+                }
+            }
+
+            if (item) {
+                i = item[0];
+                j = item[1];
+                ps = series[i].datapoints.pointsize;
+                
+                return { datapoint: series[i].datapoints.points.slice(j * ps, (j + 1) * ps),
+                         dataIndex: j,
+                         series: series[i],
+                         seriesIndex: i };
+            }
+            
+            return null;
+        }
+
+        function onMouseMove(e) {
+            if (options.grid.hoverable)
+                triggerClickHoverEvent("plothover", e,
+                                       function (s) { return s["hoverable"] != false; });
+        }
+
+        function onMouseLeave(e) {
+            if (options.grid.hoverable)
+                triggerClickHoverEvent("plothover", e,
+                                       function (s) { return false; });
+        }
+
+        function onClick(e) {
+            triggerClickHoverEvent("plotclick", e,
+                                   function (s) { return s["clickable"] != false; });
+        }
+
+        // trigger click or hover event (they send the same parameters
+        // so we share their code)
+        function triggerClickHoverEvent(eventname, event, seriesFilter) {
+            var offset = eventHolder.offset(),
+                canvasX = event.pageX - offset.left - plotOffset.left,
+                canvasY = event.pageY - offset.top - plotOffset.top,
+            pos = canvasToAxisCoords({ left: canvasX, top: canvasY });
+
+            pos.pageX = event.pageX;
+            pos.pageY = event.pageY;
+
+            var item = findNearbyItem(canvasX, canvasY, seriesFilter);
+
+            if (item) {
+                // fill in mouse pos for any listeners out there
+                item.pageX = parseInt(item.series.xaxis.p2c(item.datapoint[0]) + offset.left + plotOffset.left);
+                item.pageY = parseInt(item.series.yaxis.p2c(item.datapoint[1]) + offset.top + plotOffset.top);
+            }
+
+            if (options.grid.autoHighlight) {
+                // clear auto-highlights
+                for (var i = 0; i < highlights.length; ++i) {
+                    var h = highlights[i];
+                    if (h.auto == eventname &&
+                        !(item && h.series == item.series &&
+                          h.point[0] == item.datapoint[0] &&
+                          h.point[1] == item.datapoint[1]))
+                        unhighlight(h.series, h.point);
+                }
+                
+                if (item)
+                    highlight(item.series, item.datapoint, eventname);
+            }
+            
+            placeholder.trigger(eventname, [ pos, item ]);
+        }
+
+        function triggerRedrawOverlay() {
+            if (!redrawTimeout)
+                redrawTimeout = setTimeout(drawOverlay, 30);
+        }
+
+        function drawOverlay() {
+            redrawTimeout = null;
+
+            // draw highlights
+            octx.save();
+            octx.clearRect(0, 0, canvasWidth, canvasHeight);
+            octx.translate(plotOffset.left, plotOffset.top);
+            
+            var i, hi;
+            for (i = 0; i < highlights.length; ++i) {
+                hi = highlights[i];
+
+                if (hi.series.bars.show)
+                    drawBarHighlight(hi.series, hi.point);
+                else
+                    drawPointHighlight(hi.series, hi.point);
+            }
+            octx.restore();
+            
+            executeHooks(hooks.drawOverlay, [octx]);
+        }
+        
+        function highlight(s, point, auto) {
+            if (typeof s == "number")
+                s = series[s];
+
+            if (typeof point == "number") {
+                var ps = s.datapoints.pointsize;
+                point = s.datapoints.points.slice(ps * point, ps * (point + 1));
+            }
+
+            var i = indexOfHighlight(s, point);
+            if (i == -1) {
+                highlights.push({ series: s, point: point, auto: auto });
+
+                triggerRedrawOverlay();
+            }
+            else if (!auto)
+                highlights[i].auto = false;
+        }
+            
+        function unhighlight(s, point) {
+            if (s == null && point == null) {
+                highlights = [];
+                triggerRedrawOverlay();
+            }
+            
+            if (typeof s == "number")
+                s = series[s];
+
+            if (typeof point == "number")
+                point = s.data[point];
+
+            var i = indexOfHighlight(s, point);
+            if (i != -1) {
+                highlights.splice(i, 1);
+
+                triggerRedrawOverlay();
+            }
+        }
+        
+        function indexOfHighlight(s, p) {
+            for (var i = 0; i < highlights.length; ++i) {
+                var h = highlights[i];
+                if (h.series == s && h.point[0] == p[0]
+                    && h.point[1] == p[1])
+                    return i;
+            }
+            return -1;
+        }
+        
+        function drawPointHighlight(series, point) {
+            var x = point[0], y = point[1],
+                axisx = series.xaxis, axisy = series.yaxis;
+            
+            if (x < axisx.min || x > axisx.max || y < axisy.min || y > axisy.max)
+                return;
+            
+            var pointRadius = series.points.radius + series.points.lineWidth / 2;
+            octx.lineWidth = pointRadius;
+            octx.strokeStyle = $.color.parse(series.color).scale('a', 0.5).toString();
+            var radius = 1.5 * pointRadius,
+                x = axisx.p2c(x),
+                y = axisy.p2c(y);
+            
+            octx.beginPath();
+            if (series.points.symbol == "circle")
+                octx.arc(x, y, radius, 0, 2 * Math.PI, false);
+            else
+                series.points.symbol(octx, x, y, radius, false);
+            octx.closePath();
+            octx.stroke();
+        }
+
+        function drawBarHighlight(series, point) {
+            octx.lineWidth = series.bars.lineWidth;
+            octx.strokeStyle = $.color.parse(series.color).scale('a', 0.5).toString();
+            var fillStyle = $.color.parse(series.color).scale('a', 0.5).toString();
+            var barLeft = series.bars.align == "left" ? 0 : -series.bars.barWidth/2;
+            drawBar(point[0], point[1], point[2] || 0, barLeft, barLeft + series.bars.barWidth,
+                    0, function () { return fillStyle; }, series.xaxis, series.yaxis, octx, series.bars.horizontal, series.bars.lineWidth);
+        }
+
+        function getColorOrGradient(spec, bottom, top, defaultColor) {
+            if (typeof spec == "string")
+                return spec;
+            else {
+                // assume this is a gradient spec; IE currently only
+                // supports a simple vertical gradient properly, so that's
+                // what we support too
+                var gradient = ctx.createLinearGradient(0, top, 0, bottom);
+                
+                for (var i = 0, l = spec.colors.length; i < l; ++i) {
+                    var c = spec.colors[i];
+                    if (typeof c != "string") {
+                        var co = $.color.parse(defaultColor);
+                        if (c.brightness != null)
+                            co = co.scale('rgb', c.brightness)
+                        if (c.opacity != null)
+                            co.a *= c.opacity;
+                        c = co.toString();
+                    }
+                    gradient.addColorStop(i / (l - 1), c);
+                }
+                
+                return gradient;
+            }
+        }
+    }
+
+    $.plot = function(placeholder, data, options) {
+        //var t0 = new Date();
+        var plot = new Plot($(placeholder), data, options, $.plot.plugins);
+        //(window.console ? console.log : alert)("time used (msecs): " + ((new Date()).getTime() - t0.getTime()));
+        return plot;
+    };
+
+    $.plot.version = "0.7";
+    
+    $.plot.plugins = [];
+
+    // returns a string with the date d formatted according to fmt
+    $.plot.formatDate = function(d, fmt, monthNames) {
+        var leftPad = function(n) {
+            n = "" + n;
+            return n.length == 1 ? "0" + n : n;
+        };
+        
+        var r = [];
+        var escape = false, padNext = false;
+        var hours = d.getUTCHours();
+        var isAM = hours < 12;
+        if (monthNames == null)
+            monthNames = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+
+        if (fmt.search(/%p|%P/) != -1) {
+            if (hours > 12) {
+                hours = hours - 12;
+            } else if (hours == 0) {
+                hours = 12;
+            }
+        }
+        for (var i = 0; i < fmt.length; ++i) {
+            var c = fmt.charAt(i);
+            
+            if (escape) {
+                switch (c) {
+                case 'h': c = "" + hours; break;
+                case 'H': c = leftPad(hours); break;
+                case 'M': c = leftPad(d.getUTCMinutes()); break;
+                case 'S': c = leftPad(d.getUTCSeconds()); break;
+                case 'd': c = "" + d.getUTCDate(); break;
+                case 'm': c = "" + (d.getUTCMonth() + 1); break;
+                case 'y': c = "" + d.getUTCFullYear(); break;
+                case 'b': c = "" + monthNames[d.getUTCMonth()]; break;
+                case 'p': c = (isAM) ? ("" + "am") : ("" + "pm"); break;
+                case 'P': c = (isAM) ? ("" + "AM") : ("" + "PM"); break;
+                case '0': c = ""; padNext = true; break;
+                }
+                if (c && padNext) {
+                    c = leftPad(c);
+                    padNext = false;
+                }
+                r.push(c);
+                if (!padNext)
+                    escape = false;
+            }
+            else {
+                if (c == "%")
+                    escape = true;
+                else
+                    r.push(c);
+            }
+        }
+        return r.join("");
+    };
+    
+    // round to nearby lower multiple of base
+    function floorInBase(n, base) {
+        return base * Math.floor(n / base);
+    }
+    
+})(jQuery);
diff --git a/module/web/static/js/libs/jquery.mobile-1.1.1.min.js b/module/web/static/js/libs/jquery.mobile-1.1.1.min.js
new file mode 100644
index 000000000..70f71928f
--- /dev/null
+++ b/module/web/static/js/libs/jquery.mobile-1.1.1.min.js
@@ -0,0 +1,181 @@
+/*! jQuery Mobile v1.1.1 1981b3f5ec22675ae47df8f0bdf9622e7780e90e jquerymobile.com | jquery.org/license */
+(function(l,t,k){typeof define==="function"&&define.amd?define(["jquery"],function(E){k(E,l,t);return E.mobile}):k(l.jQuery,l,t)})(this,document,function(l,t,k,E){(function(a,c,b,d){function e(a){for(;a&&typeof a.originalEvent!=="undefined";)a=a.originalEvent;return a}function g(b){for(var e={},g,d;b;){g=a.data(b,s);for(d in g)if(g[d])e[d]=e.hasVirtualBinding=true;b=b.parentNode}return e}function f(){y&&(clearTimeout(y),y=0);y=setTimeout(function(){G=y=0;A.length=0;F=false;H=true},a.vmouse.resetTimerDuration)}
+function j(b,g,c){var f,h;if(!(h=c&&c[b])){if(c=!c)a:{for(c=g.target;c;){if((h=a.data(c,s))&&(!b||h[b]))break a;c=c.parentNode}c=null}h=c}if(h){f=g;var c=f.type,j,F;f=a.Event(f);f.type=b;h=f.originalEvent;j=a.event.props;c.search(/^(mouse|click)/)>-1&&(j=w);if(h)for(F=j.length;F;)b=j[--F],f[b]=h[b];if(c.search(/mouse(down|up)|click/)>-1&&!f.which)f.which=1;if(c.search(/^touch/)!==-1&&(b=e(h),c=b.touches,b=b.changedTouches,c=c&&c.length?c[0]:b&&b.length?b[0]:d))for(h=0,len=x.length;h<len;h++)b=x[h],
+f[b]=c[b];a(g.target).trigger(f)}return f}function h(b){var e=a.data(b.target,u);if(!F&&(!G||G!==e))if(e=j("v"+b.type,b))e.isDefaultPrevented()&&b.preventDefault(),e.isPropagationStopped()&&b.stopPropagation(),e.isImmediatePropagationStopped()&&b.stopImmediatePropagation()}function q(b){var c=e(b).touches,d;if(c&&c.length===1&&(d=b.target,c=g(d),c.hasVirtualBinding))G=N++,a.data(d,u,G),y&&(clearTimeout(y),y=0),z=H=false,d=e(b).touches[0],t=d.pageX,C=d.pageY,j("vmouseover",b,c),j("vmousedown",b,c)}
+function o(a){H||(z||j("vmousecancel",a,g(a.target)),z=true,f())}function m(b){if(!H){var c=e(b).touches[0],d=z,h=a.vmouse.moveDistanceThreshold;z=z||Math.abs(c.pageX-t)>h||Math.abs(c.pageY-C)>h;flags=g(b.target);z&&!d&&j("vmousecancel",b,flags);j("vmousemove",b,flags);f()}}function v(a){if(!H){H=true;var b=g(a.target),c;j("vmouseup",a,b);if(!z&&(c=j("vclick",a,b))&&c.isDefaultPrevented())c=e(a).changedTouches[0],A.push({touchID:G,x:c.clientX,y:c.clientY}),F=true;j("vmouseout",a,b);z=false;f()}}function n(b){var b=
+a.data(b,s),e;if(b)for(e in b)if(b[e])return true;return false}function k(){}function p(b){var e=b.substr(1);return{setup:function(){n(this)||a.data(this,s,{});a.data(this,s)[b]=true;l[b]=(l[b]||0)+1;l[b]===1&&J.bind(e,h);a(this).bind(e,k);if(M)l.touchstart=(l.touchstart||0)+1,l.touchstart===1&&J.bind("touchstart",q).bind("touchend",v).bind("touchmove",m).bind("scroll",o)},teardown:function(){--l[b];l[b]||J.unbind(e,h);M&&(--l.touchstart,l.touchstart||J.unbind("touchstart",q).unbind("touchmove",m).unbind("touchend",
+v).unbind("scroll",o));var g=a(this),c=a.data(this,s);c&&(c[b]=false);g.unbind(e,k);n(this)||g.removeData(s)}}}var s="virtualMouseBindings",u="virtualTouchID",c="vmouseover vmousedown vmousemove vmouseup vclick vmouseout vmousecancel".split(" "),x="clientX clientY pageX pageY screenX screenY".split(" "),w=a.event.props.concat(a.event.mouseHooks?a.event.mouseHooks.props:[]),l={},y=0,t=0,C=0,z=false,A=[],F=false,H=false,M="addEventListener"in b,J=a(b),N=1,G=0;a.vmouse={moveDistanceThreshold:10,clickDistanceThreshold:10,
+resetTimerDuration:1500};for(var K=0;K<c.length;K++)a.event.special[c[K]]=p(c[K]);M&&b.addEventListener("click",function(b){var e=A.length,g=b.target,c,d,f,h,j;if(e){c=b.clientX;d=b.clientY;threshold=a.vmouse.clickDistanceThreshold;for(f=g;f;){for(h=0;h<e;h++)if(j=A[h],f===g&&Math.abs(j.x-c)<threshold&&Math.abs(j.y-d)<threshold||a.data(f,u)===j.touchID){b.preventDefault();b.stopPropagation();return}f=f.parentNode}}},true)})(l,t,k);(function(a,c,b){function d(a){a=a||location.href;return"#"+a.replace(/^[^#]*#?(.*)$/,
+"$1")}var e="hashchange",g=k,f,j=a.event.special,h=g.documentMode,q="on"+e in c&&(h===b||h>7);a.fn[e]=function(a){return a?this.bind(e,a):this.trigger(e)};a.fn[e].delay=50;j[e]=a.extend(j[e],{setup:function(){if(q)return false;a(f.start)},teardown:function(){if(q)return false;a(f.stop)}});f=function(){function f(){var b=d(),g=s(n);if(b!==n)p(n=b,g),a(c).trigger(e);else if(g!==n)location.href=location.href.replace(/#.*/,"")+g;j=setTimeout(f,a.fn[e].delay)}var h={},j,n=d(),k=function(a){return a},p=
+k,s=k;h.start=function(){j||f()};h.stop=function(){j&&clearTimeout(j);j=b};a.browser.msie&&!q&&function(){var b,c;h.start=function(){if(!b)c=(c=a.fn[e].src)&&c+d(),b=a('<iframe tabindex="-1" title="empty"/>').hide().one("load",function(){c||p(d());f()}).attr("src",c||"javascript:0").insertAfter("body")[0].contentWindow,g.onpropertychange=function(){try{if(event.propertyName==="title")b.document.title=g.title}catch(a){}}};h.stop=k;s=function(){return d(b.location.href)};p=function(c,d){var f=b.document,
+h=a.fn[e].domain;if(c!==d)f.title=g.title,f.open(),h&&f.write('<script>document.domain="'+h+'"<\/script>'),f.close(),b.location.hash=c}}();return h}()})(l,this);(function(a,c){if(a.cleanData){var b=a.cleanData;a.cleanData=function(e){for(var c=0,f;(f=e[c])!=null;c++)a(f).triggerHandler("remove");b(e)}}else{var d=a.fn.remove;a.fn.remove=function(b,c){return this.each(function(){c||(!b||a.filter(b,[this]).length)&&a("*",this).add([this]).each(function(){a(this).triggerHandler("remove")});return d.call(a(this),
+b,c)})}}a.widget=function(b,c,f){var d=b.split(".")[0],h,b=b.split(".")[1];h=d+"-"+b;if(!f)f=c,c=a.Widget;a.expr[":"][h]=function(c){return!!a.data(c,b)};a[d]=a[d]||{};a[d][b]=function(a,b){arguments.length&&this._createWidget(a,b)};c=new c;c.options=a.extend(true,{},c.options);a[d][b].prototype=a.extend(true,c,{namespace:d,widgetName:b,widgetEventPrefix:a[d][b].prototype.widgetEventPrefix||b,widgetBaseClass:h},f);a.widget.bridge(b,a[d][b])};a.widget.bridge=function(b,g){a.fn[b]=function(d){var j=
+typeof d==="string",h=Array.prototype.slice.call(arguments,1),q=this,d=!j&&h.length?a.extend.apply(null,[true,d].concat(h)):d;if(j&&d.charAt(0)==="_")return q;j?this.each(function(){var g=a.data(this,b);if(!g)throw"cannot call methods on "+b+" prior to initialization; attempted to call method '"+d+"'";if(!a.isFunction(g[d]))throw"no such method '"+d+"' for "+b+" widget instance";var j=g[d].apply(g,h);if(j!==g&&j!==c)return q=j,false}):this.each(function(){var c=a.data(this,b);c?c.option(d||{})._init():
+a.data(this,b,new g(d,this))});return q}};a.Widget=function(a,b){arguments.length&&this._createWidget(a,b)};a.Widget.prototype={widgetName:"widget",widgetEventPrefix:"",options:{disabled:false},_createWidget:function(b,c){a.data(c,this.widgetName,this);this.element=a(c);this.options=a.extend(true,{},this.options,this._getCreateOptions(),b);var d=this;this.element.bind("remove."+this.widgetName,function(){d.destroy()});this._create();this._trigger("create");this._init()},_getCreateOptions:function(){var b=
+{};a.metadata&&(b=a.metadata.get(element)[this.widgetName]);return b},_create:function(){},_init:function(){},destroy:function(){this.element.unbind("."+this.widgetName).removeData(this.widgetName);this.widget().unbind("."+this.widgetName).removeAttr("aria-disabled").removeClass(this.widgetBaseClass+"-disabled ui-state-disabled")},widget:function(){return this.element},option:function(b,d){var f=b;if(arguments.length===0)return a.extend({},this.options);if(typeof b==="string"){if(d===c)return this.options[b];
+f={};f[b]=d}this._setOptions(f);return this},_setOptions:function(b){var c=this;a.each(b,function(a,b){c._setOption(a,b)});return this},_setOption:function(a,b){this.options[a]=b;a==="disabled"&&this.widget()[b?"addClass":"removeClass"](this.widgetBaseClass+"-disabled ui-state-disabled").attr("aria-disabled",b);return this},enable:function(){return this._setOption("disabled",false)},disable:function(){return this._setOption("disabled",true)},_trigger:function(b,c,d){var j=this.options[b],c=a.Event(c);
+c.type=(b===this.widgetEventPrefix?b:this.widgetEventPrefix+b).toLowerCase();d=d||{};if(c.originalEvent)for(var b=a.event.props.length,h;b;)h=a.event.props[--b],c[h]=c.originalEvent[h];this.element.trigger(c,d);return!(a.isFunction(j)&&j.call(this.element[0],c,d)===false||c.isDefaultPrevented())}}})(l);(function(a,c){a.widget("mobile.widget",{_createWidget:function(){a.Widget.prototype._createWidget.apply(this,arguments);this._trigger("init")},_getCreateOptions:function(){var b=this.element,d={};
+a.each(this.options,function(a){var g=b.jqmData(a.replace(/[A-Z]/g,function(a){return"-"+a.toLowerCase()}));g!==c&&(d[a]=g)});return d},enhanceWithin:function(b,c){this.enhance(a(this.options.initSelector,a(b)),c)},enhance:function(b,c){var e,g=a(b),g=a.mobile.enhanceable(g);c&&g.length&&(e=(e=a.mobile.closestPageData(g))&&e.keepNativeSelector()||"",g=g.not(e));g[this.widgetName]()},raise:function(a){throw"Widget ["+this.widgetName+"]: "+a;}})})(l);(function(a,c){var b={};a.mobile=a.extend({},{version:"1.1.1",
+ns:"",subPageUrlKey:"ui-page",activePageClass:"ui-page-active",activeBtnClass:"ui-btn-active",focusClass:"ui-focus",ajaxEnabled:true,hashListeningEnabled:true,linkBindingEnabled:true,defaultPageTransition:"fade",maxTransitionWidth:false,minScrollBack:250,touchOverflowEnabled:false,defaultDialogTransition:"pop",loadingMessage:"loading",pageLoadErrorMessage:"Error Loading Page",loadingMessageTextVisible:false,loadingMessageTheme:"a",pageLoadErrorMessageTheme:"e",autoInitializePage:true,pushStateEnabled:true,
+ignoreContentEnabled:false,orientationChangeEnabled:true,buttonMarkup:{hoverDelay:200},keyCode:{ALT:18,BACKSPACE:8,CAPS_LOCK:20,COMMA:188,COMMAND:91,COMMAND_LEFT:91,COMMAND_RIGHT:93,CONTROL:17,DELETE:46,DOWN:40,END:35,ENTER:13,ESCAPE:27,HOME:36,INSERT:45,LEFT:37,MENU:93,NUMPAD_ADD:107,NUMPAD_DECIMAL:110,NUMPAD_DIVIDE:111,NUMPAD_ENTER:108,NUMPAD_MULTIPLY:106,NUMPAD_SUBTRACT:109,PAGE_DOWN:34,PAGE_UP:33,PERIOD:190,RIGHT:39,SHIFT:16,SPACE:32,TAB:9,UP:38,WINDOWS:91},silentScroll:function(b){if(a.type(b)!==
+"number")b=a.mobile.defaultHomeScroll;a.event.special.scrollstart.enabled=false;setTimeout(function(){c.scrollTo(0,b);a(k).trigger("silentscroll",{x:0,y:b})},20);setTimeout(function(){a.event.special.scrollstart.enabled=true},150)},nsNormalizeDict:b,nsNormalize:function(c){return!c?void 0:b[c]||(b[c]=a.camelCase(a.mobile.ns+c))},getInheritedTheme:function(a,b){for(var c=a[0],d="",e=/ui-(bar|body|overlay)-([a-z])\b/,o,m;c;){if((o=c.className||"")&&(m=e.exec(o))&&(d=m[2]))break;c=c.parentNode}return d||
+b||"a"},closestPageData:function(a){return a.closest(':jqmData(role="page"), :jqmData(role="dialog")').data("page")},enhanceable:function(a){return this.haveParents(a,"enhance")},hijackable:function(a){return this.haveParents(a,"ajax")},haveParents:function(b,c){if(!a.mobile.ignoreContentEnabled)return b;for(var d=b.length,e=a(),q,o,m,v=0;v<d;v++){o=b.eq(v);m=false;for(q=b[v];q;){if((q.getAttribute?q.getAttribute("data-"+a.mobile.ns+c):"")==="false"){m=true;break}q=q.parentNode}m||(e=e.add(o))}return e},
+getScreenHeight:function(){return c.innerHeight||a(c).height()}},a.mobile);a.fn.jqmData=function(b,c){var d;typeof b!="undefined"&&(b&&(b=a.mobile.nsNormalize(b)),d=this.data.apply(this,arguments.length<2?[b]:[b,c]));return d};a.jqmData=function(b,c,d){var e;typeof c!="undefined"&&(e=a.data(b,c?a.mobile.nsNormalize(c):c,d));return e};a.fn.jqmRemoveData=function(b){return this.removeData(a.mobile.nsNormalize(b))};a.jqmRemoveData=function(b,c){return a.removeData(b,a.mobile.nsNormalize(c))};a.fn.removeWithDependents=
+function(){a.removeWithDependents(this)};a.removeWithDependents=function(b){b=a(b);(b.jqmData("dependents")||a()).remove();b.remove()};a.fn.addDependents=function(b){a.addDependents(a(this),b)};a.addDependents=function(b,c){var d=a(b).jqmData("dependents")||a();a(b).jqmData("dependents",a.merge(d,c))};a.fn.getEncodedText=function(){return a("<div/>").text(a(this).text()).html()};a.fn.jqmEnhanceable=function(){return a.mobile.enhanceable(this)};a.fn.jqmHijackable=function(){return a.mobile.hijackable(this)};
+var d=a.find,e=/:jqmData\(([^)]*)\)/g;a.find=function(b,c,j,h){b=b.replace(e,"[data-"+(a.mobile.ns||"")+"$1]");return d.call(this,b,c,j,h)};a.extend(a.find,d);a.find.matches=function(b,c){return a.find(b,null,null,c)};a.find.matchesSelector=function(b,c){return a.find(c,null,null,[b]).length>0}})(l,this);(function(a){a(t);var c=a("html");a.mobile.media=function(){var b={},d=a("<div id='jquery-mediatest'></div>"),e=a("<body>").append(d);return function(a){if(!(a in b)){var f=k.createElement("style"),
+j="@media "+a+" { #jquery-mediatest { position:absolute; } }";f.type="text/css";f.styleSheet?f.styleSheet.cssText=j:f.appendChild(k.createTextNode(j));c.prepend(e).prepend(f);b[a]=d.css("position")==="absolute";e.add(f).remove()}return b[a]}}()})(l);(function(a,c){function b(a){var b=a.charAt(0).toUpperCase()+a.substr(1),a=(a+" "+f.join(b+" ")+b).split(" "),d;for(d in a)if(g[a[d]]!==c)return true}function d(a,b,c){var d=k.createElement("div"),c=c?[c]:f,e;for(i=0;i<c.length;i++){var h=c[i],j="-"+h.charAt(0).toLowerCase()+
+h.substr(1)+"-"+a+": "+b+";",h=h.charAt(0).toUpperCase()+h.substr(1)+(a.charAt(0).toUpperCase()+a.substr(1));d.setAttribute("style",j);d.style[h]&&(e=true)}return!!e}var e=a("<body>").prependTo("html"),g=e[0].style,f=["Webkit","Moz","O"],j="palmGetResource"in t,h=t.opera,q=t.operamini&&{}.toString.call(t.operamini)==="[object OperaMini]",o=t.blackberry;a.extend(a.mobile,{browser:{}});a.mobile.browser.ie=function(){for(var a=3,b=k.createElement("div"),c=b.all||[];b.innerHTML="<\!--[if gt IE "+ ++a+
+"]><br><![endif]--\>",c[0];);return a>4?a:!a}();a.extend(a.support,{orientation:"orientation"in t&&"onorientationchange"in t,touch:"ontouchend"in k,cssTransitions:"WebKitTransitionEvent"in t||d("transition","height 100ms linear")&&!h,pushState:"pushState"in history&&"replaceState"in history,mediaquery:a.mobile.media("only all"),cssPseudoElement:!!b("content"),touchOverflow:!!b("overflowScrolling"),cssTransform3d:d("perspective","10px","moz")||a.mobile.media("(-"+f.join("-transform-3d),(-")+"-transform-3d),(transform-3d)"),
+boxShadow:!!b("boxShadow")&&!o,scrollTop:("pageXOffset"in t||"scrollTop"in k.documentElement||"scrollTop"in e[0])&&!j&&!q,dynamicBaseTag:function(){var b=location.protocol+"//"+location.host+location.pathname+"ui-dir/",c=a("head base"),d=null,h="",f;c.length?h=c.attr("href"):c=d=a("<base>",{href:b}).appendTo("head");f=a("<a href='testurl' />").prependTo(e)[0].href;c[0].href=h||location.pathname;d&&d.remove();return f.indexOf(b)===0}(),cssPointerEvents:function(){var a=k.createElement("x"),b=k.documentElement,
+c=t.getComputedStyle;if(!("pointerEvents"in a.style))return false;a.style.pointerEvents="auto";a.style.pointerEvents="x";b.appendChild(a);c=c&&c(a,"").pointerEvents==="auto";b.removeChild(a);return!!c}()});e.remove();j=function(){var a=t.navigator.userAgent;return a.indexOf("Nokia")>-1&&(a.indexOf("Symbian/3")>-1||a.indexOf("Series60/5")>-1)&&a.indexOf("AppleWebKit")>-1&&a.match(/(BrowserNG|NokiaBrowser)\/7\.[0-3]/)}();a.mobile.gradeA=function(){return a.support.mediaquery||a.mobile.browser.ie&&a.mobile.browser.ie>=
+7};a.mobile.ajaxBlacklist=t.blackberry&&!t.WebKitPoint||q||j;j&&a(function(){a("head link[rel='stylesheet']").attr("rel","alternate stylesheet").attr("rel","stylesheet")});a.support.boxShadow||a("html").addClass("ui-mobile-nosupport-boxshadow")})(l);(function(a,c,b){function d(b,c,d){var e=d.type;d.type=c;a.event.handle.call(b,d);d.type=e}a.each("touchstart touchmove touchend orientationchange throttledresize tap taphold swipe swipeleft swiperight scrollstart scrollstop".split(" "),function(b,c){a.fn[c]=
+function(a){return a?this.bind(c,a):this.trigger(c)};a.attrFn[c]=true});var e=a.support.touch,g=e?"touchstart":"mousedown",f=e?"touchend":"mouseup",j=e?"touchmove":"mousemove";a.event.special.scrollstart={enabled:true,setup:function(){function b(a,h){e=h;d(c,e?"scrollstart":"scrollstop",a)}var c=this,e,f;a(c).bind("touchmove scroll",function(c){a.event.special.scrollstart.enabled&&(e||b(c,true),clearTimeout(f),f=setTimeout(function(){b(c,false)},50))})}};a.event.special.tap={setup:function(){var b=
+this,c=a(b);c.bind("vmousedown",function(e){function f(){clearTimeout(p)}function j(){f();c.unbind("vclick",g).unbind("vmouseup",f);a(k).unbind("vmousecancel",j)}function g(a){j();r==a.target&&d(b,"tap",a)}if(e.which&&e.which!==1)return false;var r=e.target,p;c.bind("vmouseup",f).bind("vclick",g);a(k).bind("vmousecancel",j);p=setTimeout(function(){d(b,"taphold",a.Event("taphold",{target:r}))},750)})}};a.event.special.swipe={scrollSupressionThreshold:10,durationThreshold:1E3,horizontalDistanceThreshold:30,
+verticalDistanceThreshold:75,setup:function(){var c=a(this);c.bind(g,function(d){function e(b){if(k){var c=b.originalEvent.touches?b.originalEvent.touches[0]:b;n={time:(new Date).getTime(),coords:[c.pageX,c.pageY]};Math.abs(k.coords[0]-n.coords[0])>a.event.special.swipe.scrollSupressionThreshold&&b.preventDefault()}}var g=d.originalEvent.touches?d.originalEvent.touches[0]:d,k={time:(new Date).getTime(),coords:[g.pageX,g.pageY],origin:a(d.target)},n;c.bind(j,e).one(f,function(){c.unbind(j,e);k&&n&&
+n.time-k.time<a.event.special.swipe.durationThreshold&&Math.abs(k.coords[0]-n.coords[0])>a.event.special.swipe.horizontalDistanceThreshold&&Math.abs(k.coords[1]-n.coords[1])<a.event.special.swipe.verticalDistanceThreshold&&k.origin.trigger("swipe").trigger(k.coords[0]>n.coords[0]?"swipeleft":"swiperight");k=n=b})})}};(function(a,b){function c(){var a=e();a!==f&&(f=a,d.trigger("orientationchange"))}var d=a(b),e,f,j,g,l={0:true,180:true};if(a.support.orientation&&(j=b.innerWidth||a(b).width(),g=b.innerHeight||
+a(b).height(),j=j>g&&j-g>50,g=l[b.orientation],j&&g||!j&&!g))l={"-90":true,90:true};a.event.special.orientationchange={setup:function(){if(a.support.orientation&&a.mobile.orientationChangeEnabled)return false;f=e();d.bind("throttledresize",c)},teardown:function(){if(a.support.orientation&&a.mobile.orientationChangeEnabled)return false;d.unbind("throttledresize",c)},add:function(a){var b=a.handler;a.handler=function(a){a.orientation=e();return b.apply(this,arguments)}}};a.event.special.orientationchange.orientation=
+e=function(){var c=true,c=k.documentElement;return(c=a.support.orientation?l[b.orientation]:c&&c.clientWidth/c.clientHeight<1.1)?"portrait":"landscape"}})(l,c);(function(){a.event.special.throttledresize={setup:function(){a(this).bind("resize",b)},teardown:function(){a(this).unbind("resize",b)}};var b=function(){e=(new Date).getTime();f=e-c;f>=250?(c=e,a(this).trigger("throttledresize")):(d&&clearTimeout(d),d=setTimeout(b,250-f))},c=0,d,e,f})();a.each({scrollstop:"scrollstart",taphold:"tap",swipeleft:"swipe",
+swiperight:"swipe"},function(b,c){a.event.special[b]={setup:function(){a(this).bind(c,a.noop)}}})})(l,this);(function(a){a.widget("mobile.page",a.mobile.widget,{options:{theme:"c",domCache:false,keepNativeDefault:":jqmData(role='none'), :jqmData(role='nojs')"},_create:function(){var a=this;if(a._trigger("beforecreate")===false)return false;a.element.attr("tabindex","0").addClass("ui-page ui-body-"+a.options.theme).bind("pagebeforehide",function(){a.removeContainerBackground()}).bind("pagebeforeshow",
+function(){a.setContainerBackground()})},removeContainerBackground:function(){a.mobile.pageContainer.removeClass("ui-overlay-"+a.mobile.getInheritedTheme(this.element.parent()))},setContainerBackground:function(c){this.options.theme&&a.mobile.pageContainer.addClass("ui-overlay-"+(c||this.options.theme))},keepNativeSelector:function(){var c=this.options;return c.keepNative&&a.trim(c.keepNative)&&c.keepNative!==c.keepNativeDefault?[c.keepNative,c.keepNativeDefault].join(", "):c.keepNativeDefault}})})(l);
+(function(a,c,b){var d=function(d){d===b&&(d=true);return function(b,e,h,q){var k=new a.Deferred,m=e?" reverse":"",l=a.mobile.urlHistory.getActive().lastScroll||a.mobile.defaultHomeScroll,n=a.mobile.getScreenHeight(),r=a.mobile.maxTransitionWidth!==false&&a(c).width()>a.mobile.maxTransitionWidth,p=!a.support.cssTransitions||r||!b||b==="none"||Math.max(a(c).scrollTop(),l)>a.mobile.getMaxScrollForTransition(),s=function(){a.mobile.pageContainer.toggleClass("ui-mobile-viewport-transitioning viewport-"+
+b)},u=function(){a.event.special.scrollstart.enabled=false;c.scrollTo(0,l);setTimeout(function(){a.event.special.scrollstart.enabled=true},150)},x=function(){q.removeClass(a.mobile.activePageClass+" out in reverse "+b).height("")},r=function(){q&&d&&x();h.addClass(a.mobile.activePageClass);a.mobile.focusPage(h);h.height(n+l);u();p||h.animationComplete(w);h.addClass(b+" in"+m);p&&w()},w=function(){d||q&&x();h.removeClass("out in reverse "+b).height("");s();a(c).scrollTop()!==l&&u();k.resolve(b,e,h,
+q,true)};s();q&&!p?(d?q.animationComplete(r):r(),q.height(n+a(c).scrollTop()).addClass(b+" out"+m)):r();return k.promise()}},e=d(),d=d(false);a.mobile.defaultTransitionHandler=e;a.mobile.transitionHandlers={"default":a.mobile.defaultTransitionHandler,sequential:e,simultaneous:d};a.mobile.transitionFallbacks={};a.mobile.getMaxScrollForTransition=a.mobile.getMaxScrollForTransition||function(){return a.mobile.getScreenHeight()*3}})(l,this);(function(a,c){function b(b){l&&(!l.closest(".ui-page-active").length||
+b)&&l.removeClass(a.mobile.activeBtnClass);l=null}function d(){p=false;r.length>0&&a.mobile.changePage.apply(null,r.pop())}function e(b,c,d,e){c&&c.data("page")._trigger("beforehide",null,{nextPage:b});b.data("page")._trigger("beforeshow",null,{prevPage:c||a("")});a.mobile.hidePageLoadingMsg();d&&!a.support.cssTransform3d&&a.mobile.transitionFallbacks[d]&&(d=a.mobile.transitionFallbacks[d]);d=(a.mobile.transitionHandlers[d||"default"]||a.mobile.defaultTransitionHandler)(d,e,b,c);d.done(function(){c&&
+c.data("page")._trigger("hide",null,{nextPage:b});b.data("page")._trigger("show",null,{prevPage:c||a("")})});return d}function g(){var b=a("."+a.mobile.activePageClass),c=parseFloat(b.css("padding-top")),d=parseFloat(b.css("padding-bottom")),e=parseFloat(b.css("border-top-width")),f=parseFloat(b.css("border-bottom-width"));b.css("min-height",y()-c-d-e-f)}function f(b,c){c&&b.attr("data-"+a.mobile.ns+"role",c);b.page()}function j(a){for(;a;){if(typeof a.nodeName==="string"&&a.nodeName.toLowerCase()==
+"a")break;a=a.parentNode}return a}function h(b){var b=a(b).closest(".ui-page").jqmData("url"),c=w.hrefNoHash;if(!b||!m.isPath(b))b=c;return m.makeUrlAbsolute(b,c)}var q=a(t);a("html");var o=a("head"),m={urlParseRE:/^(((([^:\/#\?]+:)?(?:(\/\/)((?:(([^:@\/#\?]+)(?:\:([^:@\/#\?]+))?)@)?(([^:\/#\?\]\[]+|\[[^\/\]@#?]+\])(?:\:([0-9]+))?))?)?)?((\/?(?:[^\/\?#]+\/+)*)([^\?#]*)))?(\?[^#]+)?)(#.*)?/,parseUrl:function(b){if(a.type(b)==="object")return b;b=m.urlParseRE.exec(b||"")||[];return{href:b[0]||"",hrefNoHash:b[1]||
+"",hrefNoSearch:b[2]||"",domain:b[3]||"",protocol:b[4]||"",doubleSlash:b[5]||"",authority:b[6]||"",username:b[8]||"",password:b[9]||"",host:b[10]||"",hostname:b[11]||"",port:b[12]||"",pathname:b[13]||"",directory:b[14]||"",filename:b[15]||"",search:b[16]||"",hash:b[17]||""}},makePathAbsolute:function(a,b){if(a&&a.charAt(0)==="/")return a;for(var a=a||"",c=(b=b?b.replace(/^\/|(\/[^\/]*|[^\/]+)$/g,""):"")?b.split("/"):[],d=a.split("/"),e=0;e<d.length;e++){var f=d[e];switch(f){case ".":break;case "..":c.length&&
+c.pop();break;default:c.push(f)}}return"/"+c.join("/")},isSameDomain:function(a,b){return m.parseUrl(a).domain===m.parseUrl(b).domain},isRelativeUrl:function(a){return m.parseUrl(a).protocol===""},isAbsoluteUrl:function(a){return m.parseUrl(a).protocol!==""},makeUrlAbsolute:function(a,b){if(!m.isRelativeUrl(a))return a;var c=m.parseUrl(a),d=m.parseUrl(b),e=c.protocol||d.protocol,f=c.protocol?c.doubleSlash:c.doubleSlash||d.doubleSlash,h=c.authority||d.authority,j=c.pathname!=="",g=m.makePathAbsolute(c.pathname||
+d.filename,d.pathname);return e+f+h+g+(c.search||!j&&d.search||"")+c.hash},addSearchParams:function(b,c){var d=m.parseUrl(b),e=typeof c==="object"?a.param(c):c,f=d.search||"?";return d.hrefNoSearch+f+(f.charAt(f.length-1)!=="?"?"&":"")+e+(d.hash||"")},convertUrlToDataUrl:function(a){var b=m.parseUrl(a);if(m.isEmbeddedPage(b))return b.hash.split(s)[0].replace(/^#/,"");else if(m.isSameDomain(b,w))return b.hrefNoHash.replace(w.domain,"").split(s)[0];return a},get:function(a){if(a===c)a=location.hash;
+return m.stripHash(a).replace(/[^\/]*\.[^\/*]+$/,"")},getFilePath:function(b){var c="&"+a.mobile.subPageUrlKey;return b&&b.split(c)[0].split(s)[0]},set:function(a){location.hash=a},isPath:function(a){return/\//.test(a)},clean:function(a){return a.replace(w.domain,"")},stripHash:function(a){return a.replace(/^#/,"")},cleanHash:function(a){return m.stripHash(a.replace(/\?.*$/,"").replace(s,""))},isHashValid:function(a){return/^#[^#]+$/.test(a)},isExternal:function(a){a=m.parseUrl(a);return a.protocol&&
+a.domain!==x.domain?true:false},hasProtocol:function(a){return/^(:?\w+:)/.test(a)},isFirstPageUrl:function(b){var b=m.parseUrl(m.makeUrlAbsolute(b,w)),d=a.mobile.firstPage,d=d&&d[0]?d[0].id:c;return(b.hrefNoHash===x.hrefNoHash||D&&b.hrefNoHash===w.hrefNoHash)&&(!b.hash||b.hash==="#"||d&&b.hash.replace(/^#/,"")===d)},isEmbeddedPage:function(a){a=m.parseUrl(a);return a.protocol!==""?a.hash&&(a.hrefNoHash===x.hrefNoHash||D&&a.hrefNoHash===w.hrefNoHash):/^#/.test(a.href)},isPermittedCrossDomainRequest:function(b,
+c){return a.mobile.allowCrossDomainPages&&b.protocol==="file:"&&c.search(/^https?:/)!=-1}},l=null,n={stack:[],activeIndex:0,getActive:function(){return n.stack[n.activeIndex]},getPrev:function(){return n.stack[n.activeIndex-1]},getNext:function(){return n.stack[n.activeIndex+1]},addNew:function(a,b,c,d,e){n.getNext()&&n.clearForward();n.stack.push({url:a,transition:b,title:c,pageUrl:d,role:e});n.activeIndex=n.stack.length-1},clearForward:function(){n.stack=n.stack.slice(0,n.activeIndex+1)},directHashChange:function(b){var d,
+e,f;this.getActive();a.each(n.stack,function(a,c){b.currentUrl===c.url&&(d=a<n.activeIndex,e=!d,f=a)});this.activeIndex=f!==c?f:this.activeIndex;d?(b.either||b.isBack)(true):e&&(b.either||b.isForward)(false)},ignoreNextHashChange:false},r=[],p=false,s="&ui-state=dialog",u=o.children("base"),x=m.parseUrl(location.href),w=u.length?m.parseUrl(m.makeUrlAbsolute(u.attr("href"),x.href)):x,D=x.hrefNoHash!==w.hrefNoHash,y=a.mobile.getScreenHeight,B=a.support.dynamicBaseTag?{element:u.length?u:a("<base>",
+{href:w.hrefNoHash}).prependTo(o),set:function(a){B.element.attr("href",m.makeUrlAbsolute(a,w))},reset:function(){B.element.attr("href",w.hrefNoHash)}}:c;a.mobile.focusPage=function(a){var b=a.find("[autofocus]"),c=a.find(".ui-title:eq(0)");b.length?b.focus():c.length?c.focus():a.focus()};var C=true,z,A;z=function(){if(C){var b=a.mobile.urlHistory.getActive();if(b){var c=q.scrollTop();b.lastScroll=c<a.mobile.minScrollBack?a.mobile.defaultHomeScroll:c}}};A=function(){setTimeout(z,100)};q.bind(a.support.pushState?
+"popstate":"hashchange",function(){C=false});q.one(a.support.pushState?"popstate":"hashchange",function(){C=true});q.one("pagecontainercreate",function(){a.mobile.pageContainer.bind("pagechange",function(){C=true;q.unbind("scrollstop",A);q.bind("scrollstop",A)})});q.bind("scrollstop",A);a.fn.animationComplete=function(b){return a.support.cssTransitions?a(this).one("webkitAnimationEnd animationend",b):(setTimeout(b,0),a(this))};a.mobile.path=m;a.mobile.base=B;a.mobile.urlHistory=n;a.mobile.dialogHashKey=
+s;a.mobile.allowCrossDomainPages=false;a.mobile.getDocumentUrl=function(b){return b?a.extend({},x):x.href};a.mobile.getDocumentBase=function(b){return b?a.extend({},w):w.href};a.mobile._bindPageRemove=function(){var b=a(this);!b.data("page").options.domCache&&b.is(":jqmData(external-page='true')")&&b.bind("pagehide.remove",function(){var b=a(this),c=new a.Event("pageremove");b.trigger(c);c.isDefaultPrevented()||b.removeWithDependents()})};a.mobile.loadPage=function(b,d){var e=a.Deferred(),j=a.extend({},
+a.mobile.loadPage.defaults,d),g=null,q=null,k=m.makeUrlAbsolute(b,a.mobile.activePage&&h(a.mobile.activePage)||w.hrefNoHash);if(j.data&&j.type==="get")k=m.addSearchParams(k,j.data),j.data=c;if(j.data&&j.type==="post")j.reloadPage=true;var n=m.getFilePath(k),o=m.convertUrlToDataUrl(k);j.pageContainer=j.pageContainer||a.mobile.pageContainer;g=j.pageContainer.children(":jqmData(url='"+o+"')");g.length===0&&o&&!m.isPath(o)&&(g=j.pageContainer.children("#"+o).attr("data-"+a.mobile.ns+"url",o));if(g.length===
+0)if(a.mobile.firstPage&&m.isFirstPageUrl(n))a.mobile.firstPage.parent().length&&(g=a(a.mobile.firstPage));else if(m.isEmbeddedPage(n))return e.reject(k,d),e.promise();B&&B.reset();if(g.length){if(!j.reloadPage)return f(g,j.role),e.resolve(k,d,g),e.promise();q=g}var l=j.pageContainer,u=new a.Event("pagebeforeload"),p={url:b,absUrl:k,dataUrl:o,deferred:e,options:j};l.trigger(u,p);if(u.isDefaultPrevented())return e.promise();if(j.showLoadMsg)var r=setTimeout(function(){a.mobile.showPageLoadingMsg()},
+j.loadMsgDelay);!a.mobile.allowCrossDomainPages&&!m.isSameDomain(x,k)?e.reject(k,d):a.ajax({url:n,type:j.type,data:j.data,dataType:"html",success:function(c,h,x){var l=a("<div></div>"),u=c.match(/<title[^>]*>([^<]*)/)&&RegExp.$1,w=RegExp("\\bdata-"+a.mobile.ns+"url=[\"']?([^\"'>]*)[\"']?");RegExp("(<[^>]+\\bdata-"+a.mobile.ns+"role=[\"']?page[\"']?[^>]*>)").test(c)&&RegExp.$1&&w.test(RegExp.$1)&&RegExp.$1&&(b=n=m.getFilePath(RegExp.$1));B&&B.set(n);l.get(0).innerHTML=c;g=l.find(":jqmData(role='page'), :jqmData(role='dialog')").first();
+g.length||(g=a("<div data-"+a.mobile.ns+"role='page'>"+c.split(/<\/?body[^>]*>/gmi)[1]+"</div>"));u&&!g.jqmData("title")&&(~u.indexOf("&")&&(u=a("<div>"+u+"</div>").text()),g.jqmData("title",u));if(!a.support.dynamicBaseTag){var s=m.get(n);g.find("[src], link[href], a[rel='external'], :jqmData(ajax='false'), a[target]").each(function(){var b=a(this).is("[href]")?"href":a(this).is("[src]")?"src":"action",c=a(this).attr(b),c=c.replace(location.protocol+"//"+location.host+location.pathname,"");/^(\w+:|#|\/)/.test(c)||
+a(this).attr(b,s+c)})}g.attr("data-"+a.mobile.ns+"url",m.convertUrlToDataUrl(n)).attr("data-"+a.mobile.ns+"external-page",true).appendTo(j.pageContainer);g.one("pagecreate",a.mobile._bindPageRemove);f(g,j.role);k.indexOf("&"+a.mobile.subPageUrlKey)>-1&&(g=j.pageContainer.children(":jqmData(url='"+o+"')"));j.showLoadMsg&&(clearTimeout(r),a.mobile.hidePageLoadingMsg());p.xhr=x;p.textStatus=h;p.page=g;j.pageContainer.trigger("pageload",p);e.resolve(k,d,g,q)},error:function(b,c,f){B&&B.set(m.get());p.xhr=
+b;p.textStatus=c;p.errorThrown=f;b=new a.Event("pageloadfailed");j.pageContainer.trigger(b,p);b.isDefaultPrevented()||(j.showLoadMsg&&(clearTimeout(r),a.mobile.hidePageLoadingMsg(),a.mobile.showPageLoadingMsg(a.mobile.pageLoadErrorMessageTheme,a.mobile.pageLoadErrorMessage,true),setTimeout(a.mobile.hidePageLoadingMsg,1500)),e.reject(k,d))}});return e.promise()};a.mobile.loadPage.defaults={type:"get",data:c,reloadPage:false,role:c,showLoadMsg:false,pageContainer:c,loadMsgDelay:50};a.mobile.changePage=
+function(j,g){if(p)r.unshift(arguments);else{var h=a.extend({},a.mobile.changePage.defaults,g);h.pageContainer=h.pageContainer||a.mobile.pageContainer;h.fromPage=h.fromPage||a.mobile.activePage;var q=h.pageContainer,o=new a.Event("pagebeforechange"),l={toPage:j,options:h};q.trigger(o,l);if(!o.isDefaultPrevented())if(j=l.toPage,p=true,typeof j=="string")a.mobile.loadPage(j,h).done(function(b,c,d,e){p=false;c.duplicateCachedPage=e;a.mobile.changePage(d,c)}).fail(function(){p=false;b(true);d();h.pageContainer.trigger("pagechangefailed",
+l)});else{if(j[0]===a.mobile.firstPage[0]&&!h.dataUrl)h.dataUrl=x.hrefNoHash;var o=h.fromPage,u=h.dataUrl&&m.convertUrlToDataUrl(h.dataUrl)||j.jqmData("url"),w=u;m.getFilePath(u);var v=n.getActive(),t=n.activeIndex===0,y=0,D=k.title,B=h.role==="dialog"||j.jqmData("role")==="dialog";if(o&&o[0]===j[0]&&!h.allowSamePageTransition)p=false,q.trigger("pagechange",l),h.fromHashChange&&n.directHashChange({currentUrl:u,isBack:function(){},isForward:function(){}});else{f(j,h.role);h.fromHashChange&&n.directHashChange({currentUrl:u,
+isBack:function(){y=-1},isForward:function(){y=1}});try{k.activeElement&&k.activeElement.nodeName.toLowerCase()!="body"?a(k.activeElement).blur():a("input:focus, textarea:focus, select:focus").blur()}catch(z){}var C=false;if(B&&v){if(v.url.indexOf(s)>-1&&!a.mobile.activePage.is(".ui-dialog"))h.changeHash=false,C=true;u=(v.url||"")+s;n.activeIndex===0&&u===n.initialDst&&(u+=s)}if(h.changeHash!==false&&u)n.ignoreNextHashChange=true,m.set(u);var A=!v?D:j.jqmData("title")||j.children(":jqmData(role='header')").find(".ui-title").getEncodedText();
+A&&D==k.title&&(D=A);j.jqmData("title")||j.jqmData("title",D);h.transition=h.transition||(y&&!t?v.transition:c)||(B?a.mobile.defaultDialogTransition:a.mobile.defaultPageTransition);!y&&!C&&n.addNew(u,h.transition,D,w,h.role);k.title=n.getActive().title;a.mobile.activePage=j;h.reverse=h.reverse||y<0;e(j,o,h.transition,h.reverse).done(function(c,e,f,g,m){b();h.duplicateCachedPage&&h.duplicateCachedPage.remove();m||a.mobile.focusPage(j);d();q.trigger("pagechange",l)})}}}};a.mobile.changePage.defaults=
+{transition:c,reverse:false,changeHash:true,fromHashChange:false,role:c,duplicateCachedPage:c,pageContainer:c,showLoadMsg:true,dataUrl:c,fromPage:c,allowSamePageTransition:false};a.mobile.navreadyDeferred=a.Deferred();a.mobile.navreadyDeferred.done(function(){a(k).delegate("form","submit",function(b){var c=a(this);if(a.mobile.ajaxEnabled&&!c.is(":jqmData(ajax='false')")&&c.jqmHijackable().length){var d=c.attr("method"),e=c.attr("target"),j=c.attr("action");if(!j&&(j=h(c),j===w.hrefNoHash))j=x.hrefNoSearch;
+j=m.makeUrlAbsolute(j,h(c));m.isExternal(j)&&!m.isPermittedCrossDomainRequest(x,j)||e||(a.mobile.changePage(j,{type:d&&d.length&&d.toLowerCase()||"get",data:c.serialize(),transition:c.jqmData("transition"),direction:c.jqmData("direction"),reloadPage:true}),b.preventDefault())}});a(k).bind("vclick",function(c){if(!(c.which>1)&&a.mobile.linkBindingEnabled&&(c=j(c.target),a(c).jqmHijackable().length&&c&&m.parseUrl(c.getAttribute("href")||"#").hash!=="#"))b(true),l=a(c).closest(".ui-btn").not(".ui-disabled"),
+l.addClass(a.mobile.activeBtnClass)});a(k).bind("click",function(d){if(a.mobile.linkBindingEnabled){var e=j(d.target),f=a(e),g;if(e&&!(d.which>1)&&f.jqmHijackable().length){g=function(){t.setTimeout(function(){b(true)},200)};if(f.is(":jqmData(rel='back')"))return t.history.back(),false;var k=h(f),e=m.makeUrlAbsolute(f.attr("href")||"#",k);if(!a.mobile.ajaxEnabled&&!m.isEmbeddedPage(e))g();else{if(e.search("#")!=-1)if(e=e.replace(/[^#]*#/,""))e=m.isPath(e)?m.makeUrlAbsolute(e,k):m.makeUrlAbsolute("#"+
+e,x.hrefNoHash);else{d.preventDefault();return}f.is("[rel='external']")||f.is(":jqmData(ajax='false')")||f.is("[target]")||m.isExternal(e)&&!m.isPermittedCrossDomainRequest(x,e)?g():(g=f.jqmData("transition"),k=(k=f.jqmData("direction"))&&k==="reverse"||f.jqmData("back"),f=f.attr("data-"+a.mobile.ns+"rel")||c,a.mobile.changePage(e,{transition:g,reverse:k,role:f}),d.preventDefault())}}}});a(k).delegate(".ui-page","pageshow.prefetch",function(){var b=[];a(this).find("a:jqmData(prefetch)").each(function(){var c=
+a(this),d=c.attr("href");d&&a.inArray(d,b)===-1&&(b.push(d),a.mobile.loadPage(d,{role:c.attr("data-"+a.mobile.ns+"rel")}))})});a.mobile._handleHashChange=function(b){var d=m.stripHash(b),e={transition:a.mobile.urlHistory.stack.length===0?"none":c,changeHash:false,fromHashChange:true};if(0===n.stack.length)n.initialDst=d;if(!a.mobile.hashListeningEnabled||n.ignoreNextHashChange)n.ignoreNextHashChange=false;else{if(n.stack.length>1&&d.indexOf(s)>-1&&n.initialDst!==d)if(a.mobile.activePage.is(".ui-dialog"))n.directHashChange({currentUrl:d,
+either:function(b){var c=a.mobile.urlHistory.getActive();d=c.pageUrl;a.extend(e,{role:c.role,transition:c.transition,reverse:b})}});else{n.directHashChange({currentUrl:d,isBack:function(){t.history.back()},isForward:function(){t.history.forward()}});return}d?(d=typeof d==="string"&&!m.isPath(d)?m.makeUrlAbsolute("#"+d,w):d,a.mobile.changePage(d,e)):a.mobile.changePage(a.mobile.firstPage,e)}};q.bind("hashchange",function(){a.mobile._handleHashChange(location.hash)});a(k).bind("pageshow",g);a(t).bind("throttledresize",
+g)})})(l);(function(a,c){var b={},d=a(c),e=a.mobile.path.parseUrl(location.href),g=a.Deferred(),f=a.Deferred();a(k).ready(a.proxy(f,"resolve"));a(k).one("mobileinit",a.proxy(g,"resolve"));a.extend(b,{initialFilePath:e.pathname+e.search,hashChangeTimeout:200,hashChangeEnableTimer:E,initialHref:e.hrefNoHash,state:function(){return{hash:location.hash||"#"+b.initialFilePath,title:k.title,initialHref:b.initialHref}},resetUIKeys:function(b){var c="&"+a.mobile.subPageUrlKey,d=b.indexOf(a.mobile.dialogHashKey);
+d>-1?b=b.slice(0,d)+"#"+b.slice(d):b.indexOf(c)>-1&&(b=b.split(c).join("#"+c));return b},nextHashChangePrevented:function(c){a.mobile.urlHistory.ignoreNextHashChange=c;b.onHashChangeDisabled=c},onHashChange:function(){if(!b.onHashChangeDisabled){var c,d;c=location.hash;var e=a.mobile.path.isPath(c),f=e?location.href:a.mobile.getDocumentUrl();c=e?c.replace("#",""):c;d=b.state();c=a.mobile.path.makeUrlAbsolute(c,f);e&&(c=b.resetUIKeys(c));history.replaceState(d,k.title,c)}},onPopState:function(c){if(c=
+c.originalEvent.state)clearTimeout(b.hashChangeEnableTimer),b.nextHashChangePrevented(false),a.mobile._handleHashChange(c.hash),b.nextHashChangePrevented(true),b.hashChangeEnableTimer=setTimeout(function(){b.nextHashChangePrevented(false)},b.hashChangeTimeout)},init:function(){d.bind("hashchange",b.onHashChange);d.bind("popstate",b.onPopState);location.hash===""&&history.replaceState(b.state(),k.title,location.href)}});a.when(f,g,a.mobile.navreadyDeferred).done(function(){a.mobile.pushStateEnabled&&
+a.support.pushState&&b.init()})})(l,this);l.mobile.transitionFallbacks.pop="fade";(function(a){a.mobile.transitionHandlers.slide=a.mobile.transitionHandlers.simultaneous;a.mobile.transitionFallbacks.slide="fade"})(l,this);l.mobile.transitionFallbacks.slidedown="fade";l.mobile.transitionFallbacks.slideup="fade";l.mobile.transitionFallbacks.flip="fade";l.mobile.transitionFallbacks.flow="fade";l.mobile.transitionFallbacks.turn="fade";(function(a){a.mobile.page.prototype.options.degradeInputs={color:false,
+date:false,datetime:false,"datetime-local":false,email:false,month:false,number:false,range:"number",search:"text",tel:false,time:false,url:false,week:false};a(k).bind("pagecreate create",function(c){var b=a.mobile.closestPageData(a(c.target)),d;if(b)d=b.options,a(c.target).find("input").not(b.keepNativeSelector()).each(function(){var b=a(this),c=this.getAttribute("type"),f=d.degradeInputs[c]||"text";if(d.degradeInputs[c]){var j=a("<div>").html(b.clone()).html(),h=j.indexOf(" type=")>-1;b.replaceWith(j.replace(h?
+/\s+type=["']?\w+['"]?/:/\/?>/,' type="'+f+'" data-'+a.mobile.ns+'type="'+c+'"'+(h?"":">")))}})})})(l);(function(a,c){a.widget("mobile.dialog",a.mobile.widget,{options:{closeBtnText:"Close",overlayTheme:"a",initSelector:":jqmData(role='dialog')"},_create:function(){var b=this,c=this.element,e=a("<a href='#' data-"+a.mobile.ns+"icon='delete' data-"+a.mobile.ns+"iconpos='notext'>"+this.options.closeBtnText+"</a>"),g=a("<div/>",{role:"dialog","class":"ui-dialog-contain ui-corner-all ui-overlay-shadow"});
+c.addClass("ui-dialog ui-overlay-"+this.options.overlayTheme);c.wrapInner(g).children().find(":jqmData(role='header')").prepend(e).end().children(":first-child").addClass("ui-corner-top").end().children(":last-child").addClass("ui-corner-bottom");e.bind("click",function(){b.close()});c.bind("vclick submit",function(b){var b=a(b.target).closest(b.type==="vclick"?"a":"form"),c;b.length&&!b.jqmData("transition")&&(c=a.mobile.urlHistory.getActive()||{},b.attr("data-"+a.mobile.ns+"transition",c.transition||
+a.mobile.defaultDialogTransition).attr("data-"+a.mobile.ns+"direction","reverse"))}).bind("pagehide",function(){b._isClosed=false;a(this).find("."+a.mobile.activeBtnClass).not(".ui-slider-bg").removeClass(a.mobile.activeBtnClass)}).bind("pagebeforeshow",function(){b.options.overlayTheme&&b.element.page("removeContainerBackground").page("setContainerBackground",b.options.overlayTheme)})},close:function(){if(!this._isClosed)this._isClosed=true,a.mobile.hashListeningEnabled?c.history.back():a.mobile.changePage(a.mobile.urlHistory.getPrev().url)}});
+a(k).delegate(a.mobile.dialog.prototype.options.initSelector,"pagecreate",function(){a.mobile.dialog.prototype.enhance(this)})})(l,this);(function(a){a.mobile.page.prototype.options.backBtnText="Back";a.mobile.page.prototype.options.addBackBtn=false;a.mobile.page.prototype.options.backBtnTheme=null;a.mobile.page.prototype.options.headerTheme="a";a.mobile.page.prototype.options.footerTheme="a";a.mobile.page.prototype.options.contentTheme=null;a(k).bind("pagecreate",function(c){var b=a(c.target),d=
+b.data("page").options,e=b.jqmData("role"),g=d.theme;a(":jqmData(role='header'), :jqmData(role='footer'), :jqmData(role='content')",b).jqmEnhanceable().each(function(){var c=a(this),j=c.jqmData("role"),h=c.jqmData("theme"),k=h||d.contentTheme||e==="dialog"&&g,o;c.addClass("ui-"+j);if(j==="header"||j==="footer"){var m=h||(j==="header"?d.headerTheme:d.footerTheme)||g;c.addClass("ui-bar-"+m).attr("role",j==="header"?"banner":"contentinfo");j==="header"&&(h=c.children("a"),o=h.hasClass("ui-btn-left"),
+k=h.hasClass("ui-btn-right"),o=o||h.eq(0).not(".ui-btn-right").addClass("ui-btn-left").length,k||h.eq(1).addClass("ui-btn-right"));d.addBackBtn&&j==="header"&&a(".ui-page").length>1&&b.jqmData("url")!==a.mobile.path.stripHash(location.hash)&&!o&&a("<a href='javascript:void(0);' class='ui-btn-left' data-"+a.mobile.ns+"rel='back' data-"+a.mobile.ns+"icon='arrow-l'>"+d.backBtnText+"</a>").attr("data-"+a.mobile.ns+"theme",d.backBtnTheme||m).prependTo(c);c.children("h1, h2, h3, h4, h5, h6").addClass("ui-title").attr({role:"heading",
+"aria-level":"1"})}else j==="content"&&(k&&c.addClass("ui-body-"+k),c.attr("role","main"))})})})(l);(function(a){a.fn.fieldcontain=function(){return this.addClass("ui-field-contain ui-body ui-br").contents().filter(function(){return this.nodeType===3&&!/\S/.test(this.nodeValue)}).remove()};a(k).bind("pagecreate create",function(c){a(":jqmData(role='fieldcontain')",c.target).jqmEnhanceable().fieldcontain()})})(l);(function(a){a.fn.grid=function(c){return this.each(function(){var b=a(this),d=a.extend({grid:null},
+c),e=b.children(),g={solo:1,a:2,b:3,c:4,d:5},d=d.grid;if(!d)if(e.length<=5)for(var f in g)g[f]===e.length&&(d=f);else d="a",b.addClass("ui-grid-duo");g=g[d];b.addClass("ui-grid-"+d);e.filter(":nth-child("+g+"n+1)").addClass("ui-block-a");g>1&&e.filter(":nth-child("+g+"n+2)").addClass("ui-block-b");g>2&&e.filter(":nth-child(3n+3)").addClass("ui-block-c");g>3&&e.filter(":nth-child(4n+4)").addClass("ui-block-d");g>4&&e.filter(":nth-child(5n+5)").addClass("ui-block-e")})}})(l);(function(a){a(k).bind("pagecreate create",
+function(c){a(":jqmData(role='nojs')",c.target).addClass("ui-nojs")})})(l);(function(a,c){function b(a){for(var b;a;){if((b=typeof a.className==="string"&&a.className+" ")&&b.indexOf("ui-btn ")>-1&&b.indexOf("ui-disabled ")<0)break;a=a.parentNode}return a}a.fn.buttonMarkup=function(b){for(var b=b&&a.type(b)=="object"?b:{},g=0;g<this.length;g++){var f=this.eq(g),j=f[0],h=a.extend({},a.fn.buttonMarkup.defaults,{icon:b.icon!==c?b.icon:f.jqmData("icon"),iconpos:b.iconpos!==c?b.iconpos:f.jqmData("iconpos"),
+theme:b.theme!==c?b.theme:f.jqmData("theme")||a.mobile.getInheritedTheme(f,"c"),inline:b.inline!==c?b.inline:f.jqmData("inline"),shadow:b.shadow!==c?b.shadow:f.jqmData("shadow"),corners:b.corners!==c?b.corners:f.jqmData("corners"),iconshadow:b.iconshadow!==c?b.iconshadow:f.jqmData("iconshadow"),mini:b.mini!==c?b.mini:f.jqmData("mini")},b),q="ui-btn-inner",o,m,l,n,r,p;a.each(h,function(b,c){j.setAttribute("data-"+a.mobile.ns+b,c);f.jqmData(b,c)});(p=a.data(j.tagName==="INPUT"||j.tagName==="BUTTON"?
+j.parentNode:j,"buttonElements"))?(j=p.outer,f=a(j),l=p.inner,n=p.text,a(p.icon).remove(),p.icon=null):(l=k.createElement(h.wrapperEls),n=k.createElement(h.wrapperEls));r=h.icon?k.createElement("span"):null;d&&!p&&d();if(!h.theme)h.theme=a.mobile.getInheritedTheme(f,"c");o="ui-btn ui-btn-up-"+h.theme;o+=h.inline?" ui-btn-inline":"";o+=h.shadow?" ui-shadow":"";o+=h.corners?" ui-btn-corner-all":"";h.mini!==c&&(o+=h.mini?" ui-mini":" ui-fullsize");h.inline!==c&&(o+=h.inline===false?" ui-btn-block":" ui-btn-inline");
+if(h.icon)h.icon="ui-icon-"+h.icon,h.iconpos=h.iconpos||"left",m="ui-icon "+h.icon,h.iconshadow&&(m+=" ui-icon-shadow");h.iconpos&&(o+=" ui-btn-icon-"+h.iconpos,h.iconpos=="notext"&&!f.attr("title")&&f.attr("title",f.getEncodedText()));q+=h.corners?" ui-btn-corner-all":"";h.iconpos&&h.iconpos==="notext"&&!f.attr("title")&&f.attr("title",f.getEncodedText());p&&f.removeClass(p.bcls||"");f.removeClass("ui-link").addClass(o);l.className=q;n.className="ui-btn-text";p||l.appendChild(n);if(r&&(r.className=
+m,!p||!p.icon))r.appendChild(k.createTextNode("\u00a0")),l.appendChild(r);for(;j.firstChild&&!p;)n.appendChild(j.firstChild);p||j.appendChild(l);p={bcls:o,outer:j,inner:l,text:n,icon:r};a.data(j,"buttonElements",p);a.data(l,"buttonElements",p);a.data(n,"buttonElements",p);r&&a.data(r,"buttonElements",p)}return this};a.fn.buttonMarkup.defaults={corners:true,shadow:true,iconshadow:true,wrapperEls:"span"};var d=function(){var c=a.mobile.buttonMarkup.hoverDelay,g,f;a(k).bind({"vmousedown vmousecancel vmouseup vmouseover vmouseout focus blur scrollstart":function(d){var h,
+k=a(b(d.target)),d=d.type;if(k.length)if(h=k.attr("data-"+a.mobile.ns+"theme"),d==="vmousedown")a.support.touch?g=setTimeout(function(){k.removeClass("ui-btn-up-"+h).addClass("ui-btn-down-"+h)},c):k.removeClass("ui-btn-up-"+h).addClass("ui-btn-down-"+h);else if(d==="vmousecancel"||d==="vmouseup")k.removeClass("ui-btn-down-"+h).addClass("ui-btn-up-"+h);else if(d==="vmouseover"||d==="focus")a.support.touch?f=setTimeout(function(){k.removeClass("ui-btn-up-"+h).addClass("ui-btn-hover-"+h)},c):k.removeClass("ui-btn-up-"+
+h).addClass("ui-btn-hover-"+h);else if(d==="vmouseout"||d==="blur"||d==="scrollstart")k.removeClass("ui-btn-hover-"+h+" ui-btn-down-"+h).addClass("ui-btn-up-"+h),g&&clearTimeout(g),f&&clearTimeout(f)},"focusin focus":function(c){a(b(c.target)).addClass(a.mobile.focusClass)},"focusout blur":function(c){a(b(c.target)).removeClass(a.mobile.focusClass)}});d=null};a(k).bind("pagecreate create",function(b){a(":jqmData(role='button'), .ui-bar > a, .ui-header > a, .ui-footer > a, .ui-bar > :jqmData(role='controlgroup') > a",
+b.target).not(".ui-btn, :jqmData(role='none'), :jqmData(role='nojs')").buttonMarkup()})})(l);(function(a){a.widget("mobile.collapsible",a.mobile.widget,{options:{expandCueText:" click to expand contents",collapseCueText:" click to collapse contents",collapsed:true,heading:"h1,h2,h3,h4,h5,h6,legend",theme:null,contentTheme:null,iconTheme:"d",mini:false,initSelector:":jqmData(role='collapsible')"},_create:function(){var c=this.element,b=this.options,d=c.addClass("ui-collapsible"),e=c.children(b.heading).first(),
+g=d.wrapInner("<div class='ui-collapsible-content'></div>").find(".ui-collapsible-content"),f=c.closest(":jqmData(role='collapsible-set')").addClass("ui-collapsible-set");e.is("legend")&&(e=a("<div role='heading'>"+e.html()+"</div>").insertBefore(e),e.next().remove());if(f.length){if(!b.theme)b.theme=f.jqmData("theme")||a.mobile.getInheritedTheme(f,"c");if(!b.contentTheme)b.contentTheme=f.jqmData("content-theme");if(!b.iconPos)b.iconPos=f.jqmData("iconpos");if(!b.mini)b.mini=f.jqmData("mini")}g.addClass(b.contentTheme?
+"ui-body-"+b.contentTheme:"");e.insertBefore(g).addClass("ui-collapsible-heading").append("<span class='ui-collapsible-heading-status'></span>").wrapInner("<a href='#' class='ui-collapsible-heading-toggle'></a>").find("a").first().buttonMarkup({shadow:false,corners:false,iconpos:c.jqmData("iconpos")||b.iconPos||"left",icon:"plus",mini:b.mini,theme:b.theme}).add(".ui-btn-inner",c).addClass("ui-corner-top ui-corner-bottom");d.bind("expand collapse",function(c){if(!c.isDefaultPrevented()){c.preventDefault();
+var h=a(this),c=c.type==="collapse",k=b.contentTheme;e.toggleClass("ui-collapsible-heading-collapsed",c).find(".ui-collapsible-heading-status").text(c?b.expandCueText:b.collapseCueText).end().find(".ui-icon").toggleClass("ui-icon-minus",!c).toggleClass("ui-icon-plus",c).end().find("a").first().removeClass(a.mobile.activeBtnClass);h.toggleClass("ui-collapsible-collapsed",c);g.toggleClass("ui-collapsible-content-collapsed",c).attr("aria-hidden",c);if(k&&(!f.length||d.jqmData("collapsible-last")))e.find("a").first().add(e.find(".ui-btn-inner")).toggleClass("ui-corner-bottom",
+c),g.toggleClass("ui-corner-bottom",!c);g.trigger("updatelayout")}}).trigger(b.collapsed?"collapse":"expand");e.bind("tap",function(){e.find("a").first().addClass(a.mobile.activeBtnClass)}).bind("click",function(a){var b=e.is(".ui-collapsible-heading-collapsed")?"expand":"collapse";d.trigger(b);a.preventDefault();a.stopPropagation()})}});a(k).bind("pagecreate create",function(c){a.mobile.collapsible.prototype.enhanceWithin(c.target)})})(l);(function(a,c){a.widget("mobile.collapsibleset",a.mobile.widget,
+{options:{initSelector:":jqmData(role='collapsible-set')"},_create:function(){var b=this.element.addClass("ui-collapsible-set"),d=this.options;if(!d.theme)d.theme=a.mobile.getInheritedTheme(b,"c");if(!d.contentTheme)d.contentTheme=b.jqmData("content-theme");if(!d.corners)d.corners=b.jqmData("corners")===c?true:false;b.jqmData("collapsiblebound")||b.jqmData("collapsiblebound",true).bind("expand collapse",function(b){var c=b.type==="collapse",b=a(b.target).closest(".ui-collapsible"),d=b.data("collapsible");
+d.options.contentTheme&&b.jqmData("collapsible-last")&&(b.find(d.options.heading).first().find("a").first().toggleClass("ui-corner-bottom",c).find(".ui-btn-inner").toggleClass("ui-corner-bottom",c),b.find(".ui-collapsible-content").toggleClass("ui-corner-bottom",!c))}).bind("expand",function(b){a(b.target).closest(".ui-collapsible").siblings(".ui-collapsible").trigger("collapse")})},_init:function(){this.refresh()},refresh:function(){var b=this.options,c=this.element.children(":jqmData(role='collapsible')");
+a.mobile.collapsible.prototype.enhance(c.not(".ui-collapsible"));c.each(function(){a(this).find(a.mobile.collapsible.prototype.options.heading).find("a").first().removeClass("ui-corner-top ui-corner-bottom").find(".ui-btn-inner").removeClass("ui-corner-top ui-corner-bottom")});c.first().find("a").first().addClass(b.corners?"ui-corner-top":"").find(".ui-btn-inner").addClass("ui-corner-top");c.last().jqmData("collapsible-last",true).find("a").first().addClass(b.corners?"ui-corner-bottom":"").find(".ui-btn-inner").addClass("ui-corner-bottom")}});
+a(k).bind("pagecreate create",function(b){a.mobile.collapsibleset.prototype.enhanceWithin(b.target)})})(l);(function(a,c){a.widget("mobile.navbar",a.mobile.widget,{options:{iconpos:"top",grid:null,initSelector:":jqmData(role='navbar')"},_create:function(){var b=this.element,d=b.find("a"),e=d.filter(":jqmData(icon)").length?this.options.iconpos:c;b.addClass("ui-navbar ui-mini").attr("role","navigation").find("ul").jqmEnhanceable().grid({grid:this.options.grid});d.buttonMarkup({corners:false,shadow:false,
+inline:true,iconpos:e});b.delegate("a","vclick",function(b){a(b.target).hasClass("ui-disabled")||(d.removeClass(a.mobile.activeBtnClass),a(this).addClass(a.mobile.activeBtnClass))});b.closest(".ui-page").bind("pagebeforeshow",function(){d.filter(".ui-state-persist").addClass(a.mobile.activeBtnClass)})}});a(k).bind("pagecreate create",function(b){a.mobile.navbar.prototype.enhanceWithin(b.target)})})(l);(function(a){var c={};a.widget("mobile.listview",a.mobile.widget,{options:{theme:null,countTheme:"c",
+headerTheme:"b",dividerTheme:"b",splitIcon:"arrow-r",splitTheme:"b",inset:false,initSelector:":jqmData(role='listview')"},_create:function(){var a="";a+=this.options.inset?" ui-listview-inset ui-corner-all ui-shadow ":"";this.element.addClass(function(c,e){return e+" ui-listview "+a});this.refresh(true)},_removeCorners:function(a,c){a=a.add(a.find(".ui-btn-inner, .ui-li-link-alt, .ui-li-thumb"));c==="top"?a.removeClass("ui-corner-top ui-corner-tr ui-corner-tl"):c==="bottom"?a.removeClass("ui-corner-bottom ui-corner-br ui-corner-bl"):
+a.removeClass("ui-corner-top ui-corner-tr ui-corner-tl ui-corner-bottom ui-corner-br ui-corner-bl")},_refreshCorners:function(a){var c,e;this.options.inset&&(c=this.element.children("li"),e=a?c.not(".ui-screen-hidden"):c.filter(":visible"),this._removeCorners(c),c=e.first().addClass("ui-corner-top"),c.add(c.find(".ui-btn-inner").not(".ui-li-link-alt span:first-child")).addClass("ui-corner-top").end().find(".ui-li-link-alt, .ui-li-link-alt span:first-child").addClass("ui-corner-tr").end().find(".ui-li-thumb").not(".ui-li-icon").addClass("ui-corner-tl"),
+e=e.last().addClass("ui-corner-bottom"),e.add(e.find(".ui-btn-inner")).find(".ui-li-link-alt").addClass("ui-corner-br").end().find(".ui-li-thumb").not(".ui-li-icon").addClass("ui-corner-bl"));a||this.element.trigger("updatelayout")},_findFirstElementByTagName:function(a,c,e,g){var f={};for(f[e]=f[g]=true;a;){if(f[a.nodeName])return a;a=a[c]}return null},_getChildrenByTagName:function(b,c,e){var g=[],f={};f[c]=f[e]=true;for(b=b.firstChild;b;)f[b.nodeName]&&g.push(b),b=b.nextSibling;return a(g)},_addThumbClasses:function(b){var c,
+e,g=b.length;for(c=0;c<g;c++)e=a(this._findFirstElementByTagName(b[c].firstChild,"nextSibling","img","IMG")),e.length&&(e.addClass("ui-li-thumb"),a(this._findFirstElementByTagName(e[0].parentNode,"parentNode","li","LI")).addClass(e.is(".ui-li-icon")?"ui-li-has-icon":"ui-li-has-thumb"))},refresh:function(b){this.parentPage=this.element.closest(".ui-page");this._createSubPages();var c=this.options,e=this.element,g=e.jqmData("dividertheme")||c.dividerTheme,f=e.jqmData("splittheme"),j=e.jqmData("spliticon"),
+h=this._getChildrenByTagName(e[0],"li","LI"),l=a.support.cssPseudoElement||!a.nodeName(e[0],"ol")?0:1,o={},m,v,n,r,p,s,u;l&&e.find(".ui-li-dec").remove();if(!c.theme)c.theme=a.mobile.getInheritedTheme(this.element,"c");for(var x=0,w=h.length;x<w;x++){m=h.eq(x);v="ui-li";if(b||!m.hasClass("ui-li"))n=m.jqmData("theme")||c.theme,r=this._getChildrenByTagName(m[0],"a","A"),s=m.jqmData("role")==="list-divider",r.length&&!s?(s=m.jqmData("icon"),m.buttonMarkup({wrapperEls:"div",shadow:false,corners:false,
+iconpos:"right",icon:r.length>1||s===false?false:s||"arrow-r",theme:n}),s!=false&&r.length==1&&m.addClass("ui-li-has-arrow"),r.first().removeClass("ui-link").addClass("ui-link-inherit"),r.length>1&&(v+=" ui-li-has-alt",r=r.last(),p=f||r.jqmData("theme")||c.splitTheme,u=r.jqmData("icon"),r.appendTo(m).attr("title",r.getEncodedText()).addClass("ui-li-link-alt").empty().buttonMarkup({shadow:false,corners:false,theme:n,icon:false,iconpos:"notext"}).find(".ui-btn-inner").append(a(k.createElement("span")).buttonMarkup({shadow:true,
+corners:true,theme:p,iconpos:"notext",icon:u||s||j||c.splitIcon})))):s?(v+=" ui-li-divider ui-bar-"+g,m.attr("role","heading"),l&&(l=1)):v+=" ui-li-static ui-body-"+n;l&&v.indexOf("ui-li-divider")<0&&(n=m.is(".ui-li-static:first")?m:m.find(".ui-link-inherit"),n.addClass("ui-li-jsnumbering").prepend("<span class='ui-li-dec'>"+l++ +". </span>"));o[v]||(o[v]=[]);o[v].push(m[0])}for(v in o)a(o[v]).addClass(v).children(".ui-btn-inner").addClass(v);e.find("h1, h2, h3, h4, h5, h6").addClass("ui-li-heading").end().find("p, dl").addClass("ui-li-desc").end().find(".ui-li-aside").each(function(){var b=
+a(this);b.prependTo(b.parent())}).end().find(".ui-li-count").each(function(){a(this).closest("li").addClass("ui-li-has-count")}).addClass("ui-btn-up-"+(e.jqmData("counttheme")||this.options.countTheme)+" ui-btn-corner-all");this._addThumbClasses(h);this._addThumbClasses(e.find(".ui-link-inherit"));this._refreshCorners(b)},_idStringEscape:function(a){return a.replace(/[^a-zA-Z0-9]/g,"-")},_createSubPages:function(){var b=this.element,d=b.closest(".ui-page"),e=d.jqmData("url"),g=e||d[0][a.expando],
+f=b.attr("id"),j=this.options,h="data-"+a.mobile.ns,k=this,l=d.find(":jqmData(role='footer')").jqmData("id"),m;typeof c[g]==="undefined"&&(c[g]=-1);f=f||++c[g];a(b.find("li>ul, li>ol").toArray().reverse()).each(function(c){var d=a(this),g=d.attr("id")||f+"-"+c,c=d.parent(),k=a(d.prevAll().toArray().reverse()),k=k.length?k:a("<span>"+a.trim(c.contents()[0].nodeValue)+"</span>"),q=k.first().getEncodedText(),g=(e||"")+"&"+a.mobile.subPageUrlKey+"="+g,u=d.jqmData("theme")||j.theme,x=d.jqmData("counttheme")||
+b.jqmData("counttheme")||j.countTheme;m=true;d.detach().wrap("<div "+h+"role='page' "+h+"url='"+g+"' "+h+"theme='"+u+"' "+h+"count-theme='"+x+"'><div "+h+"role='content'></div></div>").parent().before("<div "+h+"role='header' "+h+"theme='"+j.headerTheme+"'><div class='ui-title'>"+q+"</div></div>").after(l?a("<div "+h+"role='footer' "+h+"id='"+l+"'>"):"").parent().appendTo(a.mobile.pageContainer).page();d=c.find("a:first");d.length||(d=a("<a/>").html(k||q).prependTo(c.empty()));d.attr("href","#"+g)}).listview();
+m&&d.is(":jqmData(external-page='true')")&&d.data("page").options.domCache===false&&d.unbind("pagehide.remove").bind("pagehide.remove",function(b,c){var f=c.nextPage,h=new a.Event("pageremove");c.nextPage&&(f=f.jqmData("url"),f.indexOf(e+"&"+a.mobile.subPageUrlKey)!==0&&(k.childPages().remove(),d.trigger(h),h.isDefaultPrevented()||d.removeWithDependents()))})},childPages:function(){var b=this.parentPage.jqmData("url");return a(":jqmData(url^='"+b+"&"+a.mobile.subPageUrlKey+"')")}});a(k).bind("pagecreate create",
+function(b){a.mobile.listview.prototype.enhanceWithin(b.target)})})(l);(function(a,c){a.widget("mobile.checkboxradio",a.mobile.widget,{options:{theme:null,initSelector:"input[type='checkbox'],input[type='radio']"},_create:function(){var b=this,d=this.element,e=a(d).closest("label"),g=e.length?e:a(d).closest("form,fieldset,:jqmData(role='page'),:jqmData(role='dialog')").find("label").filter("[for='"+d[0].id+"']"),f=d[0].type,e=d.jqmData("mini")||d.closest("form,fieldset").jqmData("mini"),j=f+"-on",
+h=f+"-off",l=d.parents(":jqmData(type='horizontal')").length?c:h,o=d.jqmData("iconpos")||d.closest("form,fieldset").jqmData("iconpos");if(!(f!=="checkbox"&&f!=="radio")){a.extend(this,{label:g,inputtype:f,checkedClass:"ui-"+j+(l?"":" "+a.mobile.activeBtnClass),uncheckedClass:"ui-"+h,checkedicon:"ui-icon-"+j,uncheckedicon:"ui-icon-"+h});if(!this.options.theme)this.options.theme=a.mobile.getInheritedTheme(this.element,"c");g.buttonMarkup({theme:this.options.theme,icon:l,shadow:false,mini:e,iconpos:o});
+e=k.createElement("div");e.className="ui-"+f;d.add(g).wrapAll(e);g.bind({vmouseover:function(b){a(this).parent().is(".ui-disabled")&&b.stopPropagation()},vclick:function(a){if(d.is(":disabled"))a.preventDefault();else return b._cacheVals(),d.prop("checked",f==="radio"&&true||!d.prop("checked")),d.triggerHandler("click"),b._getInputSet().not(d).prop("checked",false),b._updateAll(),false}});d.bind({vmousedown:function(){b._cacheVals()},vclick:function(){var c=a(this);c.is(":checked")?(c.prop("checked",
+true),b._getInputSet().not(c).prop("checked",false)):c.prop("checked",false);b._updateAll()},focus:function(){g.addClass(a.mobile.focusClass)},blur:function(){g.removeClass(a.mobile.focusClass)}});this.refresh()}},_cacheVals:function(){this._getInputSet().each(function(){a(this).jqmData("cacheVal",this.checked)})},_getInputSet:function(){return this.inputtype==="checkbox"?this.element:this.element.closest("form,fieldset,:jqmData(role='page')").find("input[name='"+this.element[0].name+"'][type='"+
+this.inputtype+"']")},_updateAll:function(){var b=this;this._getInputSet().each(function(){var c=a(this);(this.checked||b.inputtype==="checkbox")&&c.trigger("change")}).checkboxradio("refresh")},refresh:function(){var a=this.element[0],c=this.label,e=c.find(".ui-icon");a.checked?(c.addClass(this.checkedClass).removeClass(this.uncheckedClass),e.addClass(this.checkedicon).removeClass(this.uncheckedicon)):(c.removeClass(this.checkedClass).addClass(this.uncheckedClass),e.removeClass(this.checkedicon).addClass(this.uncheckedicon));
+a.disabled?this.disable():this.enable()},disable:function(){this.element.prop("disabled",true).parent().addClass("ui-disabled")},enable:function(){this.element.prop("disabled",false).parent().removeClass("ui-disabled")}});a(k).bind("pagecreate create",function(b){a.mobile.checkboxradio.prototype.enhanceWithin(b.target,true)})})(l);(function(a,c){a.widget("mobile.button",a.mobile.widget,{options:{theme:null,icon:null,iconpos:null,inline:false,corners:true,shadow:true,iconshadow:true,initSelector:"button, [type='button'], [type='submit'], [type='reset'], [type='image']",
+mini:false},_create:function(){var b=this.element,d,e=this.options,g;g="";var f;if(b[0].tagName==="A")!b.hasClass("ui-btn")&&b.buttonMarkup();else{if(!this.options.theme)this.options.theme=a.mobile.getInheritedTheme(this.element,"c");~b[0].className.indexOf("ui-btn-left")&&(g="ui-btn-left");~b[0].className.indexOf("ui-btn-right")&&(g="ui-btn-right");if(b.attr("type")==="submit"||b.attr("type")==="reset")g?g+=" ui-submit":g="ui-submit";a("label[for='"+b.attr("id")+"']").addClass("ui-submit");d=this.button=
+a("<div></div>").text(b.text()||b.val()).insertBefore(b).buttonMarkup({theme:e.theme,icon:e.icon,iconpos:e.iconpos,inline:e.inline,corners:e.corners,shadow:e.shadow,iconshadow:e.iconshadow,mini:e.mini}).addClass(g).append(b.addClass("ui-btn-hidden"));e=b.attr("type");g=b.attr("name");e!=="button"&&e!=="reset"&&g&&b.bind("vclick",function(){f===c&&(f=a("<input>",{type:"hidden",name:b.attr("name"),value:b.attr("value")}).insertBefore(b),a(k).one("submit",function(){f.remove();f=c}))});b.bind({focus:function(){d.addClass(a.mobile.focusClass)},
+blur:function(){d.removeClass(a.mobile.focusClass)}});this.refresh()}},enable:function(){this.element.attr("disabled",false);this.button.removeClass("ui-disabled").attr("aria-disabled",false);return this._setOption("disabled",false)},disable:function(){this.element.attr("disabled",true);this.button.addClass("ui-disabled").attr("aria-disabled",true);return this._setOption("disabled",true)},refresh:function(){var b=this.element;b.prop("disabled")?this.disable():this.enable();a(this.button.data("buttonElements").text).text(b.text()||
+b.val())}});a(k).bind("pagecreate create",function(b){a.mobile.button.prototype.enhanceWithin(b.target,true)})})(l);(function(a){a.fn.controlgroup=function(c){function b(a,b){a.removeClass("ui-btn-corner-all ui-corner-top ui-corner-bottom ui-corner-left ui-corner-right ui-controlgroup-last ui-shadow").eq(0).addClass(b[0]).end().last().addClass(b[1]).addClass("ui-controlgroup-last")}return this.each(function(){var d=a(this),e=a.extend({direction:d.jqmData("type")||"vertical",shadow:false,excludeInvisible:true,
+mini:d.jqmData("mini")},c),g=d.children("legend"),f=e.direction=="horizontal"?["ui-corner-left","ui-corner-right"]:["ui-corner-top","ui-corner-bottom"];d.find("input").first().attr("type");d.wrapInner("<div class='ui-controlgroup-controls'></div>");g.length&&(a("<div role='heading' class='ui-controlgroup-label'>"+g.html()+"</div>").insertBefore(d.children(0)),g.remove());d.addClass("ui-corner-all ui-controlgroup ui-controlgroup-"+e.direction);b(d.find(".ui-btn"+(e.excludeInvisible?":visible":"")).not(".ui-slider-handle"),
+f);b(d.find(".ui-btn-inner"),f);e.shadow&&d.addClass("ui-shadow");e.mini&&d.addClass("ui-mini")})}})(l);(function(a){a(k).bind("pagecreate create",function(c){a(c.target).find("a").jqmEnhanceable().not(".ui-btn, .ui-link-inherit, :jqmData(role='none'), :jqmData(role='nojs')").addClass("ui-link")})})(l);(function(a){var c=a("meta[name=viewport]"),b=c.attr("content"),d=b+",maximum-scale=1, user-scalable=no",e=b+",maximum-scale=10, user-scalable=yes",g=/(user-scalable[\s]*=[\s]*no)|(maximum-scale[\s]*=[\s]*1)[$,\s]/.test(b);
+a.mobile.zoom=a.extend({},{enabled:!g,locked:false,disable:function(b){if(!g&&!a.mobile.zoom.locked)c.attr("content",d),a.mobile.zoom.enabled=false,a.mobile.zoom.locked=b||false},enable:function(b){if(!g&&(!a.mobile.zoom.locked||b===true))c.attr("content",e),a.mobile.zoom.enabled=true,a.mobile.zoom.locked=false},restore:function(){if(!g)c.attr("content",b),a.mobile.zoom.enabled=true}})})(l);(function(a){a.widget("mobile.textinput",a.mobile.widget,{options:{theme:null,preventFocusZoom:/iPhone|iPad|iPod/.test(navigator.platform)&&
+navigator.userAgent.indexOf("AppleWebKit")>-1,initSelector:"input[type='text'], input[type='search'], :jqmData(type='search'), input[type='number'], :jqmData(type='number'), input[type='password'], input[type='email'], input[type='url'], input[type='tel'], textarea, input[type='time'], input[type='date'], input[type='month'], input[type='week'], input[type='datetime'], input[type='datetime-local'], input[type='color'], input:not([type])",clearSearchButtonText:"clear text"},_create:function(){var c=
+this.element,b=this.options,d=b.theme||a.mobile.getInheritedTheme(this.element,"c"),e=" ui-body-"+d,g=c.jqmData("mini")==true,f=g?" ui-mini":"",j,h;a("label[for='"+c.attr("id")+"']").addClass("ui-input-text");j=c.addClass("ui-input-text ui-body-"+d);typeof c[0].autocorrect!=="undefined"&&!a.support.touchOverflow&&(c[0].setAttribute("autocorrect","off"),c[0].setAttribute("autocomplete","off"));c.is("[type='search'],:jqmData(type='search')")?(j=c.wrap("<div class='ui-input-search ui-shadow-inset ui-btn-corner-all ui-btn-shadow ui-icon-searchfield"+
+e+f+"'></div>").parent(),h=a("<a href='#' class='ui-input-clear' title='"+b.clearSearchButtonText+"'>"+b.clearSearchButtonText+"</a>").bind("click",function(a){c.val("").focus().trigger("change");h.addClass("ui-input-clear-hidden");a.preventDefault()}).appendTo(j).buttonMarkup({icon:"delete",iconpos:"notext",corners:true,shadow:true,mini:g}),d=function(){setTimeout(function(){h.toggleClass("ui-input-clear-hidden",!c.val())},0)},d(),c.bind("paste cut keyup focus change blur",d)):c.addClass("ui-corner-all ui-shadow-inset"+
+e+f);c.focus(function(){j.addClass(a.mobile.focusClass)}).blur(function(){j.removeClass(a.mobile.focusClass)}).bind("focus",function(){b.preventFocusZoom&&a.mobile.zoom.disable(true)}).bind("blur",function(){b.preventFocusZoom&&a.mobile.zoom.enable(true)});if(c.is("textarea")){var l=function(){var a=c[0].scrollHeight;c[0].clientHeight<a&&c.height(a+15)},o;c.keyup(function(){clearTimeout(o);o=setTimeout(l,100)});a(k).one("pagechange",l);a.trim(c.val())&&a(t).load(l)}},disable:function(){(this.element.attr("disabled",
+true).is("[type='search'],:jqmData(type='search')")?this.element.parent():this.element).addClass("ui-disabled")},enable:function(){(this.element.attr("disabled",false).is("[type='search'],:jqmData(type='search')")?this.element.parent():this.element).removeClass("ui-disabled")}});a(k).bind("pagecreate create",function(c){a.mobile.textinput.prototype.enhanceWithin(c.target,true)})})(l);(function(a){a.mobile.listview.prototype.options.filter=false;a.mobile.listview.prototype.options.filterPlaceholder=
+"Filter items...";a.mobile.listview.prototype.options.filterTheme="c";a.mobile.listview.prototype.options.filterCallback=function(a,b){return a.toLowerCase().indexOf(b)===-1};a(k).delegate(":jqmData(role='listview')","listviewcreate",function(){var c=a(this),b=c.data("listview");if(b.options.filter){var d=a("<form>",{"class":"ui-listview-filter ui-bar-"+b.options.filterTheme,role:"search"});a("<input>",{placeholder:b.options.filterPlaceholder}).attr("data-"+a.mobile.ns+"type","search").jqmData("lastval",
+"").bind("keyup change",function(){var d=a(this),g=this.value.toLowerCase(),f=null,f=d.jqmData("lastval")+"",j=false,h="";d.jqmData("lastval",g);f=g.length<f.length||g.indexOf(f)!==0?c.children():c.children(":not(.ui-screen-hidden)");if(g){for(var k=f.length-1;k>=0;k--)d=a(f[k]),h=d.jqmData("filtertext")||d.text(),d.is("li:jqmData(role=list-divider)")?(d.toggleClass("ui-filter-hidequeue",!j),j=false):b.options.filterCallback(h,g)?d.toggleClass("ui-filter-hidequeue",true):j=true;f.filter(":not(.ui-filter-hidequeue)").toggleClass("ui-screen-hidden",
+false);f.filter(".ui-filter-hidequeue").toggleClass("ui-screen-hidden",true).toggleClass("ui-filter-hidequeue",false)}else f.toggleClass("ui-screen-hidden",false);b._refreshCorners()}).appendTo(d).textinput();b.options.inset&&d.addClass("ui-listview-filter-inset");d.bind("submit",function(){return false}).insertBefore(c)}})})(l);(function(a,c){a.widget("mobile.slider",a.mobile.widget,{options:{theme:null,trackTheme:null,disabled:false,initSelector:"input[type='range'], :jqmData(type='range'), :jqmData(role='slider')",
+mini:false},_create:function(){var b=this,d=this.element,e=a.mobile.getInheritedTheme(d,"c"),g=this.options.theme||e,e=this.options.trackTheme||e,f=d[0].nodeName.toLowerCase(),j=f=="select"?"ui-slider-switch":"",h=d.attr("id"),l=a("[for='"+h+"']"),o=l.attr("id")||h+"-label",l=l.attr("id",o),m=function(){return f=="input"?parseFloat(d.val()):d[0].selectedIndex},v=f=="input"?parseFloat(d.attr("min")):0,n=f=="input"?parseFloat(d.attr("max")):d.find("option").length-1,r=t.parseFloat(d.attr("step")||1),
+p=this.options.inline||d.jqmData("inline")==true?" ui-slider-inline":"",s=this.options.mini||d.jqmData("mini")?" ui-slider-mini":"",u=k.createElement("a"),x=a(u),h=k.createElement("div"),w=a(h),D=d.jqmData("highlight")&&f!="select"?function(){var b=k.createElement("div");b.className="ui-slider-bg "+a.mobile.activeBtnClass+" ui-btn-corner-all";return a(b).prependTo(w)}():false;u.setAttribute("href","#");h.setAttribute("role","application");h.className=["ui-slider ",j," ui-btn-down-",e," ui-btn-corner-all",
+p,s].join("");u.className="ui-slider-handle";h.appendChild(u);x.buttonMarkup({corners:true,theme:g,shadow:true}).attr({role:"slider","aria-valuemin":v,"aria-valuemax":n,"aria-valuenow":m(),"aria-valuetext":m(),title:m(),"aria-labelledby":o});a.extend(this,{slider:w,handle:x,valuebg:D,dragging:false,beforeStart:null,userModified:false,mouseMoved:false});if(f=="select"){g=k.createElement("div");g.className="ui-slider-inneroffset";j=0;for(o=h.childNodes.length;j<o;j++)g.appendChild(h.childNodes[j]);
+h.appendChild(g);x.addClass("ui-slider-handle-snapping");g=d.find("option");h=0;for(j=g.length;h<j;h++)o=!h?"b":"a",p=!h?" ui-btn-down-"+e:" "+a.mobile.activeBtnClass,k.createElement("div"),s=k.createElement("span"),s.className=["ui-slider-label ui-slider-label-",o,p," ui-btn-corner-all"].join(""),s.setAttribute("role","img"),s.appendChild(k.createTextNode(g[h].innerHTML)),a(s).prependTo(w);b._labels=a(".ui-slider-label",w)}l.addClass("ui-slider");d.addClass(f==="input"?"ui-slider-input":"ui-slider-switch").change(function(){b.mouseMoved||
+b.refresh(m(),true)}).keyup(function(){b.refresh(m(),true,true)}).blur(function(){b.refresh(m(),true)});a(k).bind("vmousemove",function(a){if(b.dragging)return b.mouseMoved=true,f==="select"&&x.removeClass("ui-slider-handle-snapping"),b.refresh(a),b.userModified=b.beforeStart!==d[0].selectedIndex,false});w.bind("vmousedown",function(a){b.dragging=true;b.userModified=false;b.mouseMoved=false;if(f==="select")b.beforeStart=d[0].selectedIndex;b.refresh(a);return false}).bind("vclick",false);w.add(k).bind("vmouseup",
+function(){if(b.dragging)return b.dragging=false,f==="select"&&(x.addClass("ui-slider-handle-snapping"),b.mouseMoved?b.userModified?b.refresh(b.beforeStart==0?1:0):b.refresh(b.beforeStart):b.refresh(b.beforeStart==0?1:0)),b.mouseMoved=false});w.insertAfter(d);f=="select"&&this.handle.bind({focus:function(){w.addClass(a.mobile.focusClass)},blur:function(){w.removeClass(a.mobile.focusClass)}});this.handle.bind({vmousedown:function(){a(this).focus()},vclick:false,keydown:function(c){var d=m();if(!b.options.disabled){switch(c.keyCode){case a.mobile.keyCode.HOME:case a.mobile.keyCode.END:case a.mobile.keyCode.PAGE_UP:case a.mobile.keyCode.PAGE_DOWN:case a.mobile.keyCode.UP:case a.mobile.keyCode.RIGHT:case a.mobile.keyCode.DOWN:case a.mobile.keyCode.LEFT:if(c.preventDefault(),
+!b._keySliding)b._keySliding=true,a(this).addClass("ui-state-active")}switch(c.keyCode){case a.mobile.keyCode.HOME:b.refresh(v);break;case a.mobile.keyCode.END:b.refresh(n);break;case a.mobile.keyCode.PAGE_UP:case a.mobile.keyCode.UP:case a.mobile.keyCode.RIGHT:b.refresh(d+r);break;case a.mobile.keyCode.PAGE_DOWN:case a.mobile.keyCode.DOWN:case a.mobile.keyCode.LEFT:b.refresh(d-r)}}},keyup:function(){if(b._keySliding)b._keySliding=false,a(this).removeClass("ui-state-active")}});this.refresh(c,c,true)},
+refresh:function(b,c,e){(this.options.disabled||this.element.attr("disabled"))&&this.disable();var g=this.element,f=g[0].nodeName.toLowerCase(),j=f==="input"?parseFloat(g.attr("min")):0,h=f==="input"?parseFloat(g.attr("max")):g.find("option").length-1,k=f==="input"&&parseFloat(g.attr("step"))>0?parseFloat(g.attr("step")):1;if(typeof b==="object"){if(!this.dragging||b.pageX<this.slider.offset().left-8||b.pageX>this.slider.offset().left+this.slider.width()+8)return;b=Math.round((b.pageX-this.slider.offset().left)/
+this.slider.width()*100)}else b==null&&(b=f==="input"?parseFloat(g.val()||0):g[0].selectedIndex),b=(parseFloat(b)-j)/(h-j)*100;if(!isNaN(b)){b<0&&(b=0);b>100&&(b=100);var l=b/100*(h-j)+j,m=(l-j)%k;l-=m;Math.abs(m)*2>=k&&(l+=m>0?k:-k);l=parseFloat(l.toFixed(5));l<j&&(l=j);l>h&&(l=h);this.handle.css("left",b+"%");this.handle.attr({"aria-valuenow":f==="input"?l:g.find("option").eq(l).attr("value"),"aria-valuetext":f==="input"?l:g.find("option").eq(l).getEncodedText(),title:f==="input"?l:g.find("option").eq(l).getEncodedText()});
+this.valuebg&&this.valuebg.css("width",b+"%");if(this._labels){var j=this.handle.width()/this.slider.width()*100,t=b&&j+(100-j)*b/100,n=b===100?0:Math.min(j+100-t,100);this._labels.each(function(){var b=a(this).is(".ui-slider-label-a");a(this).width((b?t:n)+"%")})}if(!e)e=false,f==="input"?(e=g.val()!==l,g.val(l)):(e=g[0].selectedIndex!==l,g[0].selectedIndex=l),!c&&e&&g.trigger("change")}},enable:function(){this.element.attr("disabled",false);this.slider.removeClass("ui-disabled").attr("aria-disabled",
+false);return this._setOption("disabled",false)},disable:function(){this.element.attr("disabled",true);this.slider.addClass("ui-disabled").attr("aria-disabled",true);return this._setOption("disabled",true)}});a(k).bind("pagecreate create",function(b){a.mobile.slider.prototype.enhanceWithin(b.target,true)})})(l);(function(a){a.widget("mobile.selectmenu",a.mobile.widget,{options:{theme:null,disabled:false,icon:"arrow-d",iconpos:"right",inline:false,corners:true,shadow:true,iconshadow:true,overlayTheme:"a",
+hidePlaceholderMenuItems:true,closeText:"Close",nativeMenu:true,preventFocusZoom:/iPhone|iPad|iPod/.test(navigator.platform)&&navigator.userAgent.indexOf("AppleWebKit")>-1,initSelector:"select:not(:jqmData(role='slider'))",mini:false},_button:function(){return a("<div/>")},_setDisabled:function(a){this.element.attr("disabled",a);this.button.attr("aria-disabled",a);return this._setOption("disabled",a)},_focusButton:function(){var a=this;setTimeout(function(){a.button.focus()},40)},_selectOptions:function(){return this.select.find("option")},
+_preExtension:function(){var c="";~this.element[0].className.indexOf("ui-btn-left")&&(c=" ui-btn-left");~this.element[0].className.indexOf("ui-btn-right")&&(c=" ui-btn-right");this.select=this.element.wrap("<div class='ui-select"+c+"'>");this.selectID=this.select.attr("id");this.label=a("label[for='"+this.selectID+"']").addClass("ui-select");this.isMultiple=this.select[0].multiple;if(!this.options.theme)this.options.theme=a.mobile.getInheritedTheme(this.select,"c")},_create:function(){this._preExtension();
+this._trigger("beforeCreate");this.button=this._button();var c=this,b=this.options,d=b.inline||this.select.jqmData("inline"),e=b.mini||this.select.jqmData("mini"),g=b.icon?b.iconpos||this.select.jqmData("iconpos"):false,d=this.button.text(a(this.select[0].options.item(this.select[0].selectedIndex==-1?0:this.select[0].selectedIndex)).text()).insertBefore(this.select).buttonMarkup({theme:b.theme,icon:b.icon,iconpos:g,inline:d,corners:b.corners,shadow:b.shadow,iconshadow:b.iconshadow,mini:e});b.nativeMenu&&
+t.opera&&t.opera.version&&d.addClass("ui-select-nativeonly");if(this.isMultiple)this.buttonCount=a("<span>").addClass("ui-li-count ui-btn-up-c ui-btn-corner-all").hide().appendTo(d.addClass("ui-li-has-count"));(b.disabled||this.element.attr("disabled"))&&this.disable();this.select.change(function(){c.refresh()});this.build()},build:function(){var c=this;this.select.appendTo(c.button).bind("vmousedown",function(){c.button.addClass(a.mobile.activeBtnClass)}).bind("focus",function(){c.button.addClass(a.mobile.focusClass)}).bind("blur",
+function(){c.button.removeClass(a.mobile.focusClass)}).bind("focus vmouseover",function(){c.button.trigger("vmouseover")}).bind("vmousemove",function(){c.button.removeClass(a.mobile.activeBtnClass)}).bind("change blur vmouseout",function(){c.button.trigger("vmouseout").removeClass(a.mobile.activeBtnClass)}).bind("change blur",function(){c.button.removeClass("ui-btn-down-"+c.options.theme)});c.button.bind("vmousedown",function(){c.options.preventFocusZoom&&a.mobile.zoom.disable(true)}).bind("mouseup",
+function(){c.options.preventFocusZoom&&a.mobile.zoom.enable(true)})},selected:function(){return this._selectOptions().filter(":selected")},selectedIndices:function(){var a=this;return this.selected().map(function(){return a._selectOptions().index(this)}).get()},setButtonText:function(){var c=this,b=this.selected();this.button.find(".ui-btn-text").text(function(){return!c.isMultiple?b.text():b.length?b.map(function(){return a(this).text()}).get().join(", "):c.placeholder})},setButtonCount:function(){var a=
+this.selected();this.isMultiple&&this.buttonCount[a.length>1?"show":"hide"]().text(a.length)},refresh:function(){this.setButtonText();this.setButtonCount()},open:a.noop,close:a.noop,disable:function(){this._setDisabled(true);this.button.addClass("ui-disabled")},enable:function(){this._setDisabled(false);this.button.removeClass("ui-disabled")}});a(k).bind("pagecreate create",function(c){a.mobile.selectmenu.prototype.enhanceWithin(c.target,true)})})(l);(function(a){var c=function(b){var c=b.selectID,
+e=b.label,g=b.select.closest(".ui-page"),f=a("<div>",{"class":"ui-selectmenu-screen ui-screen-hidden"}).appendTo(g),j=b._selectOptions(),h=b.isMultiple=b.select[0].multiple,l=c+"-button",o=c+"-menu",m=a("<div data-"+a.mobile.ns+"role='dialog' data-"+a.mobile.ns+"theme='"+b.options.theme+"' data-"+a.mobile.ns+"overlay-theme='"+b.options.overlayTheme+"'><div data-"+a.mobile.ns+"role='header'><div class='ui-title'>"+e.getEncodedText()+"</div></div><div data-"+a.mobile.ns+"role='content'></div></div>"),
+v=a("<div>",{"class":"ui-selectmenu ui-selectmenu-hidden ui-overlay-shadow ui-corner-all ui-body-"+b.options.overlayTheme+" "+a.mobile.defaultDialogTransition}).insertAfter(f),n=a("<ul>",{"class":"ui-selectmenu-list",id:o,role:"listbox","aria-labelledby":l}).attr("data-"+a.mobile.ns+"theme",b.options.theme).appendTo(v),r=a("<div>",{"class":"ui-header ui-bar-"+b.options.theme}).prependTo(v),p=a("<h1>",{"class":"ui-title"}).appendTo(r),s;b.isMultiple&&(s=a("<a>",{text:b.options.closeText,href:"#","class":"ui-btn-left"}).attr("data-"+
+a.mobile.ns+"iconpos","notext").attr("data-"+a.mobile.ns+"icon","delete").appendTo(r).buttonMarkup());a.extend(b,{select:b.select,selectID:c,buttonId:l,menuId:o,thisPage:g,menuPage:m,label:e,screen:f,selectOptions:j,isMultiple:h,theme:b.options.theme,listbox:v,list:n,header:r,headerTitle:p,headerClose:s,menuPageContent:void 0,menuPageClose:void 0,placeholder:"",build:function(){var c=this;c.refresh();c.select.attr("tabindex","-1").focus(function(){a(this).blur();c.button.focus()});c.button.bind("vclick keydown",
+function(b){if(b.type=="vclick"||b.keyCode&&(b.keyCode===a.mobile.keyCode.ENTER||b.keyCode===a.mobile.keyCode.SPACE))c.open(),b.preventDefault()});c.list.attr("role","listbox").bind("focusin",function(b){a(b.target).attr("tabindex","0").trigger("vmouseover")}).bind("focusout",function(b){a(b.target).attr("tabindex","-1").trigger("vmouseout")}).delegate("li:not(.ui-disabled, .ui-li-divider)","click",function(d){var e=c.select[0].selectedIndex,f=c.list.find("li:not(.ui-li-divider)").index(this),h=c._selectOptions().eq(f)[0];
+h.selected=c.isMultiple?!h.selected:true;c.isMultiple&&a(this).find(".ui-icon").toggleClass("ui-icon-checkbox-on",h.selected).toggleClass("ui-icon-checkbox-off",!h.selected);(c.isMultiple||e!==f)&&c.select.trigger("change");c.isMultiple?c.list.find("li:not(.ui-li-divider)").eq(f).addClass("ui-btn-down-"+b.options.theme).find("a").first().focus():c.close();d.preventDefault()}).keydown(function(c){var d=a(c.target),e=d.closest("li");switch(c.keyCode){case 38:return c=e.prev().not(".ui-selectmenu-placeholder"),
+c.is(".ui-li-divider")&&(c=c.prev()),c.length&&(d.blur().attr("tabindex","-1"),c.addClass("ui-btn-down-"+b.options.theme).find("a").first().focus()),false;case 40:return c=e.next(),c.is(".ui-li-divider")&&(c=c.next()),c.length&&(d.blur().attr("tabindex","-1"),c.addClass("ui-btn-down-"+b.options.theme).find("a").first().focus()),false;case 13:case 32:return d.trigger("click"),false}});c.menuPage.bind("pagehide",function(){c.list.appendTo(c.listbox);c._focusButton();a.mobile._bindPageRemove.call(c.thisPage)});
+c.screen.bind("vclick",function(){c.close()});c.isMultiple&&c.headerClose.click(function(){if(c.menuType=="overlay")return c.close(),false});c.thisPage.addDependents(this.menuPage)},_isRebuildRequired:function(){var a=this.list.find("li");return this._selectOptions().text()!==a.text()},selected:function(){return this._selectOptions().filter(":selected:not(:jqmData(placeholder='true'))")},refresh:function(b){var c=this,d;(b||this._isRebuildRequired())&&c._buildList();d=this.selectedIndices();c.setButtonText();
+c.setButtonCount();c.list.find("li:not(.ui-li-divider)").removeClass(a.mobile.activeBtnClass).attr("aria-selected",false).each(function(b){a.inArray(b,d)>-1&&(b=a(this),b.attr("aria-selected",true),c.isMultiple?b.find(".ui-icon").removeClass("ui-icon-checkbox-off").addClass("ui-icon-checkbox-on"):b.is(".ui-selectmenu-placeholder")?b.next().addClass(a.mobile.activeBtnClass):b.addClass(a.mobile.activeBtnClass))})},close:function(){if(!this.options.disabled&&this.isOpen)this.menuType=="page"?t.history.back():
+(this.screen.addClass("ui-screen-hidden"),this.listbox.addClass("ui-selectmenu-hidden").removeAttr("style").removeClass("in"),this.list.appendTo(this.listbox),this._focusButton()),this.isOpen=false},open:function(){function c(){var e=d.list.find("."+a.mobile.activeBtnClass+" a");e.length===0&&(e=d.list.find("li.ui-btn:not(:jqmData(placeholder='true')) a"));e.first().focus().closest("li").addClass("ui-btn-down-"+b.options.theme)}if(!this.options.disabled){var d=this,e=a(t),f=d.list.parent(),h=f.outerHeight(),
+f=f.outerWidth();a(".ui-page-active");var g=e.scrollTop(),j=d.button.offset().top,l=e.height(),e=e.width();d.button.addClass(a.mobile.activeBtnClass);setTimeout(function(){d.button.removeClass(a.mobile.activeBtnClass)},300);if(h>l-80||!a.support.scrollTop){d.menuPage.appendTo(a.mobile.pageContainer).page();d.menuPageContent=m.find(".ui-content");d.menuPageClose=m.find(".ui-header a");d.thisPage.unbind("pagehide.remove");if(g==0&&j>l)d.thisPage.one("pagehide",function(){a(this).jqmData("lastScroll",
+j)});d.menuPage.one("pageshow",function(){c();d.isOpen=true});d.menuType="page";d.menuPageContent.append(d.list);d.menuPage.find("div .ui-title").text(d.label.text());a.mobile.changePage(d.menuPage,{transition:a.mobile.defaultDialogTransition})}else{d.menuType="overlay";d.screen.height(a(k).height()).removeClass("ui-screen-hidden");var n=j-g,o=g+l-j,q=h/2,p=parseFloat(d.list.parent().css("max-width")),h=n>h/2&&o>h/2?j+d.button.outerHeight()/2-q:n>o?g+l-h-30:g+30;f<p?g=(e-f)/2:(g=d.button.offset().left+
+d.button.outerWidth()/2-f/2,g<30?g=30:g+f>e&&(g=e-f-30));d.listbox.append(d.list).removeClass("ui-selectmenu-hidden").css({top:h,left:g}).addClass("in");c();d.isOpen=true}}},_buildList:function(){var b=this.options,c=this.placeholder,d=true,e=this.isMultiple?"checkbox-off":"false";this.list.empty().filter(".ui-listview").listview("destroy");var f=this.select.find("option"),h=f.length,g=this.select[0],j="data-"+a.mobile.ns,l=j+"option-index",m=j+"icon",n=j+"role";j+="placeholder";for(var o=k.createDocumentFragment(),
+q=false,p,t=0;t<h;t++,q=false){var s=f[t],r=a(s),v=s.parentNode,E=r.text(),I=k.createElement("a"),L=[];I.setAttribute("href","#");I.appendChild(k.createTextNode(E));v!==g&&v.nodeName.toLowerCase()==="optgroup"&&(v=v.getAttribute("label"),v!=p&&(p=k.createElement("li"),p.setAttribute(n,"list-divider"),p.setAttribute("role","option"),p.setAttribute("tabindex","-1"),p.appendChild(k.createTextNode(v)),o.appendChild(p),p=v));if(d&&(!s.getAttribute("value")||E.length==0||r.jqmData("placeholder")))if(d=
+false,q=true,s.setAttribute(j,true),b.hidePlaceholderMenuItems&&L.push("ui-selectmenu-placeholder"),!c)c=this.placeholder=E;r=k.createElement("li");s.disabled&&(L.push("ui-disabled"),r.setAttribute("aria-disabled",true));r.setAttribute(l,t);r.setAttribute(m,e);q&&r.setAttribute(j,true);r.className=L.join(" ");r.setAttribute("role","option");I.setAttribute("tabindex","-1");r.appendChild(I);o.appendChild(r)}this.list[0].appendChild(o);!this.isMultiple&&!c.length?this.header.hide():this.headerTitle.text(this.placeholder);
+this.list.listview()},_button:function(){return a("<a>",{href:"#",role:"button",id:this.buttonId,"aria-haspopup":"true","aria-owns":this.menuId})}})};a(k).bind("selectmenubeforecreate",function(b){b=a(b.target).data("selectmenu");b.options.nativeMenu||c(b)})})(l);(function(a){a.widget("mobile.fixedtoolbar",a.mobile.widget,{options:{visibleOnPageShow:true,disablePageZoom:true,transition:"slide",fullscreen:false,tapToggle:true,tapToggleBlacklist:"a, button, input, select, textarea, .ui-header-fixed, .ui-footer-fixed",
+hideDuringFocus:"input, textarea, select",updatePagePadding:true,trackPersistentToolbars:true,supportBlacklist:function(){var a=navigator.userAgent,b=navigator.platform,d=a.match(/AppleWebKit\/([0-9]+)/),d=!!d&&d[1],e=a.match(/Fennec\/([0-9]+)/),e=!!e&&e[1],g=a.match(/Opera Mobi\/([0-9]+)/),f=!!g&&g[1];return(b.indexOf("iPhone")>-1||b.indexOf("iPad")>-1||b.indexOf("iPod")>-1)&&d&&d<534||t.operamini&&{}.toString.call(t.operamini)==="[object OperaMini]"||g&&f<7458||a.indexOf("Android")>-1&&d&&d<533||
+e&&e<6||"palmGetResource"in t&&d&&d<534||a.indexOf("MeeGo")>-1&&a.indexOf("NokiaBrowser/8.5.0")>-1?true:false},initSelector:":jqmData(position='fixed')"},_create:function(){var a=this.options,b=this.element,d=b.is(":jqmData(role='header')")?"header":"footer",e=b.closest(".ui-page");a.supportBlacklist()?this.destroy():(b.addClass("ui-"+d+"-fixed"),a.fullscreen?(b.addClass("ui-"+d+"-fullscreen"),e.addClass("ui-page-"+d+"-fullscreen")):e.addClass("ui-page-"+d+"-fixed"),this._addTransitionClass(),this._bindPageEvents(),
+this._bindToggleHandlers())},_addTransitionClass:function(){var a=this.options.transition;a&&a!=="none"&&(a==="slide"&&(a=this.element.is(".ui-header")?"slidedown":"slideup"),this.element.addClass(a))},_bindPageEvents:function(){var c=this,b=c.options;c.element.closest(".ui-page").bind("pagebeforeshow",function(){b.disablePageZoom&&a.mobile.zoom.disable(true);b.visibleOnPageShow||c.hide(true)}).bind("webkitAnimationStart animationstart updatelayout",function(){b.updatePagePadding&&c.updatePagePadding(this)}).bind("pageshow",
+function(){var d=this;c.updatePagePadding(d);b.updatePagePadding&&a(t).bind("throttledresize."+c.widgetName,function(){c.updatePagePadding(d)})}).bind("pagebeforehide",function(d,e){b.disablePageZoom&&a.mobile.zoom.enable(true);b.updatePagePadding&&a(t).unbind("throttledresize."+c.widgetName);if(b.trackPersistentToolbars){var g=a(".ui-footer-fixed:jqmData(id)",this),f=a(".ui-header-fixed:jqmData(id)",this),j=g.length&&e.nextPage&&a(".ui-footer-fixed:jqmData(id='"+g.jqmData("id")+"')",e.nextPage),
+h=f.length&&e.nextPage&&a(".ui-header-fixed:jqmData(id='"+f.jqmData("id")+"')",e.nextPage),j=j||a();if(j.length||h.length)j.add(h).appendTo(a.mobile.pageContainer),e.nextPage.one("pageshow",function(){j.add(h).appendTo(this)})}})},_visible:true,updatePagePadding:function(c){var b=this.element,d=b.is(".ui-header");this.options.fullscreen||(c=c||b.closest(".ui-page"),a(c).css("padding-"+(d?"top":"bottom"),b.outerHeight()))},_useTransition:function(c){var b=this.element,d=a(t).scrollTop(),e=b.height(),
+g=b.closest(".ui-page").height(),f=a.mobile.getScreenHeight(),b=b.is(":jqmData(role='header')")?"header":"footer";return!c&&(this.options.transition&&this.options.transition!=="none"&&(b==="header"&&!this.options.fullscreen&&d>e||b==="footer"&&!this.options.fullscreen&&d+f<g-e)||this.options.fullscreen)},show:function(a){var b=this.element;this._useTransition(a)?b.removeClass("out ui-fixed-hidden").addClass("in"):b.removeClass("ui-fixed-hidden");this._visible=true},hide:function(a){var b=this.element,
+d="out"+(this.options.transition==="slide"?" reverse":"");this._useTransition(a)?b.addClass(d).removeClass("in").animationComplete(function(){b.addClass("ui-fixed-hidden").removeClass(d)}):b.addClass("ui-fixed-hidden").removeClass(d);this._visible=false},toggle:function(){this[this._visible?"hide":"show"]()},_bindToggleHandlers:function(){var c=this,b=c.options;c.element.closest(".ui-page").bind("vclick",function(d){b.tapToggle&&!a(d.target).closest(b.tapToggleBlacklist).length&&c.toggle()}).bind("focusin focusout",
+function(d){if(screen.width<500&&a(d.target).is(b.hideDuringFocus)&&!a(d.target).closest(".ui-header-fixed, .ui-footer-fixed").length)c[d.type==="focusin"&&c._visible?"hide":"show"]()})},destroy:function(){this.element.removeClass("ui-header-fixed ui-footer-fixed ui-header-fullscreen ui-footer-fullscreen in out fade slidedown slideup ui-fixed-hidden");this.element.closest(".ui-page").removeClass("ui-page-header-fixed ui-page-footer-fixed ui-page-header-fullscreen ui-page-footer-fullscreen")}});a(k).bind("pagecreate create",
+function(c){a(c.target).jqmData("fullscreen")&&a(a.mobile.fixedtoolbar.prototype.options.initSelector,c.target).not(":jqmData(fullscreen)").jqmData("fullscreen",true);a.mobile.fixedtoolbar.prototype.enhanceWithin(c.target)})})(l);(function(a,c){if(/iPhone|iPad|iPod/.test(navigator.platform)&&navigator.userAgent.indexOf("AppleWebKit")>-1){var b=a.mobile.zoom,d,e,g,f,j;a(c).bind("orientationchange.iosorientationfix",b.enable).bind("devicemotion.iosorientationfix",function(a){d=a.originalEvent;j=d.accelerationIncludingGravity;
+e=Math.abs(j.x);g=Math.abs(j.y);f=Math.abs(j.z);!c.orientation&&(e>7||(f>6&&g<8||f<8&&g>6)&&e>5)?b.enabled&&b.disable():b.enabled||b.enable()})}})(l,this);(function(a,c){function b(){var b=a("."+a.mobile.activeBtnClass).first();j.css({top:a.support.scrollTop&&f.scrollTop()+f.height()/2||b.length&&b.offset().top||100})}function d(){var c=j.offset(),e=f.scrollTop(),g=a.mobile.getScreenHeight();if(c.top<e||c.top-e>g)j.addClass("ui-loader-fakefix"),b(),f.unbind("scroll",d).bind("scroll",b)}function e(){g.removeClass("ui-mobile-rendering")}
+var g=a("html");a("head");var f=a(c);a(c.document).trigger("mobileinit");if(a.mobile.gradeA()){if(a.mobile.ajaxBlacklist)a.mobile.ajaxEnabled=false;g.addClass("ui-mobile ui-mobile-rendering");setTimeout(e,5E3);var j=a("<div class='ui-loader'><span class='ui-icon ui-icon-loading'></span><h1></h1></div>");a.extend(a.mobile,{showPageLoadingMsg:function(b,c,e){g.addClass("ui-loading");if(a.mobile.loadingMessage){var k=e||a.mobile.loadingMessageTextVisible;b=b||a.mobile.loadingMessageTheme;j.attr("class",
+"ui-loader ui-corner-all ui-body-"+(b||"a")+" ui-loader-"+(k?"verbose":"default")+(e?" ui-loader-textonly":"")).find("h1").text(c||a.mobile.loadingMessage).end().appendTo(a.mobile.pageContainer);d();f.bind("scroll",d)}},hidePageLoadingMsg:function(){g.removeClass("ui-loading");a.mobile.loadingMessage&&j.removeClass("ui-loader-fakefix");a(c).unbind("scroll",b);a(c).unbind("scroll",d)},initializePage:function(){var b=a(":jqmData(role='page'), :jqmData(role='dialog')");b.length||(b=a("body").wrapInner("<div data-"+
+a.mobile.ns+"role='page'></div>").children(0));b.each(function(){var b=a(this);b.jqmData("url")||b.attr("data-"+a.mobile.ns+"url",b.attr("id")||location.pathname+location.search)});a.mobile.firstPage=b.first();a.mobile.pageContainer=b.first().parent().addClass("ui-mobile-viewport");f.trigger("pagecontainercreate");a.mobile.showPageLoadingMsg();e();!a.mobile.hashListeningEnabled||!a.mobile.path.isHashValid(location.hash)||!a(location.hash+':jqmData(role="page")').length&&!a.mobile.path.isPath(location.hash)?
+a.mobile.changePage(a.mobile.firstPage,{transition:"none",reverse:true,changeHash:false,fromHashChange:true}):f.trigger("hashchange",[true])}});a.mobile.navreadyDeferred.resolve();a(function(){c.scrollTo(0,1);a.mobile.defaultHomeScroll=!a.support.scrollTop||a(c).scrollTop()===1?0:1;a.fn.controlgroup&&a(k).bind("pagecreate create",function(b){a(":jqmData(role='controlgroup')",b.target).jqmEnhanceable().controlgroup({excludeInvisible:false})});a.mobile.autoInitializePage&&a.mobile.initializePage();
+f.load(a.mobile.silentScroll);a.support.cssPointerEvents||a(k).delegate(".ui-disabled","vclick",function(a){a.preventDefault();a.stopImmediatePropagation()})})}})(l,this)});
diff --git a/module/web/static/js/libs/jquery.omniwindow.js b/module/web/static/js/libs/jquery.omniwindow.js
new file mode 100644
index 000000000..e1f0b8f77
--- /dev/null
+++ b/module/web/static/js/libs/jquery.omniwindow.js
@@ -0,0 +1,141 @@
+// jQuery OmniWindow plugin
+// @version:  0.7.0
+// @author:   Rudenka Alexander (mur.mailbox@gmail.com)
+// @license:  MIT
+
+;(function($) {
+  "use strict";
+  $.fn.extend({
+    omniWindow: function(options) {
+
+      options = $.extend(true, {
+        animationsPriority: {
+          show: ['overlay', 'modal'],
+          hide: ['modal', 'overlay']
+        },
+        overlay: {
+          selector: '.ow-overlay',
+          hideClass: 'ow-closed',
+          animations: {
+            show: function(subjects, internalCallback) { return internalCallback(subjects); },
+            hide: function(subjects, internalCallback) { return internalCallback(subjects); },
+            internal: {
+              show: function(subjects){ subjects.overlay.removeClass(options.overlay.hideClass); },
+              hide: function(subjects){ subjects.overlay.addClass(options.overlay.hideClass); }
+            }
+          }
+        },
+        modal:   {
+          hideClass: 'ow-closed',
+          animations: {
+            show: function(subjects, internalCallback) { return internalCallback(subjects); },
+            hide: function(subjects, internalCallback) { return internalCallback(subjects); },
+            internal: {
+              show: function(subjects){ subjects.modal.removeClass(options.modal.hideClass); },
+              hide: function(subjects){ subjects.modal.addClass(options.modal.hideClass); }
+            }
+          },
+          internal: {
+            stateAttribute: 'ow-active'
+          }
+        },
+        eventsNames: {
+          show: 'show.ow',
+          hide: 'hide.ow',
+          internal: {
+            overlayClick:  'click.ow',
+            keyboardKeyUp: 'keyup.ow'
+          }
+        },
+        callbacks: {                                                                                  // Callbacks execution chain
+          beforeShow:  function(subjects, internalCallback) { return internalCallback(subjects); },   // 1 (stop if retruns false)
+          positioning: function(subjects, internalCallback) { return internalCallback(subjects); },   // 2
+          afterShow:   function(subjects, internalCallback) { return internalCallback(subjects); },   // 3
+          beforeHide:  function(subjects, internalCallback) { return internalCallback(subjects); },   // 4 (stop if retruns false)
+          afterHide:   function(subjects, internalCallback) { return internalCallback(subjects); },   // 5
+          internal: {
+            beforeShow: function(subjects) {
+              if (subjects.modal.data(options.modal.internal.stateAttribute)) {
+                return false;
+              } else {
+                subjects.modal.data(options.modal.internal.stateAttribute, true);
+                return true;
+              }
+            },
+            afterShow: function(subjects) {
+              $(document).on(options.eventsNames.internal.keyboardKeyUp, function(e) {
+                if (e.keyCode === 27) {                                              // if the key pressed is the ESC key
+                  subjects.modal.trigger(options.eventsNames.hide);
+                }
+              });
+
+              subjects.overlay.on(options.eventsNames.internal.overlayClick, function(){
+                subjects.modal.trigger(options.eventsNames.hide);
+              });
+            },
+            positioning: function(subjects) {
+              subjects.modal.css('margin-left', Math.round(subjects.modal.outerWidth() / -2));
+            },
+            beforeHide: function(subjects) {
+              if (subjects.modal.data(options.modal.internal.stateAttribute)) {
+                subjects.modal.data(options.modal.internal.stateAttribute, false);
+                return true;
+              } else {
+                return false;
+              }
+            },
+            afterHide: function(subjects) {
+              subjects.overlay.off(options.eventsNames.internal.overlayClick);
+              $(document).off(options.eventsNames.internal.keyboardKeyUp);
+
+              subjects.overlay.css('display', ''); // clear inline styles after jQ animations
+              subjects.modal.css('display', '');
+            }
+          }
+        }
+      }, options);
+
+      var animate = function(process, subjects, callbackName) {
+        var first  = options.animationsPriority[process][0],
+            second = options.animationsPriority[process][1];
+
+        options[first].animations[process](subjects, function(subjs) {        // call USER's    FIRST animation (depends on priority)
+          options[first].animations.internal[process](subjs);                 // call internal  FIRST animation
+
+          options[second].animations[process](subjects, function(subjs) {     // call USER's    SECOND animation
+            options[second].animations.internal[process](subjs);              // call internal  SECOND animation
+
+                                                                              // then we need to call USER's
+                                                                              // afterShow of afterHide callback
+            options.callbacks[callbackName](subjects, options.callbacks.internal[callbackName]);
+          });
+        });
+      };
+
+      var showModal = function(subjects) {
+        if (!options.callbacks.beforeShow(subjects, options.callbacks.internal.beforeShow)) { return; } // cancel showing if beforeShow callback return false
+
+        options.callbacks.positioning(subjects, options.callbacks.internal.positioning);
+
+        animate('show', subjects, 'afterShow');
+      };
+
+      var hideModal = function(subjects) {
+        if (!options.callbacks.beforeHide(subjects, options.callbacks.internal.beforeHide)) { return; } // cancel hiding if beforeHide callback return false
+
+        animate('hide', subjects, 'afterHide');
+      };
+
+
+      var $overlay = $(options.overlay.selector);
+
+      return this.each(function() {
+        var $modal  = $(this);
+        var subjects = {modal: $modal, overlay: $overlay};
+
+        $modal.bind(options.eventsNames.show, function(){ showModal(subjects); })
+              .bind(options.eventsNames.hide, function(){ hideModal(subjects); });
+      });
+    }
+  });
+})(jQuery);
\ No newline at end of file
diff --git a/module/web/static/js/libs/jquery.transit-0.9.9.js b/module/web/static/js/libs/jquery.transit-0.9.9.js
new file mode 100644
index 000000000..f0d9719dd
--- /dev/null
+++ b/module/web/static/js/libs/jquery.transit-0.9.9.js
@@ -0,0 +1,700 @@
+/*!
+ * jQuery Transit - CSS3 transitions and transformations
+ * (c) 2011-2012 Rico Sta. Cruz <rico@ricostacruz.com>
+ * MIT Licensed.
+ *
+ * http://ricostacruz.com/jquery.transit
+ * http://github.com/rstacruz/jquery.transit
+ */
+
+(function($) {
+  $.transit = {
+    version: "0.9.9",
+
+    // Map of $.css() keys to values for 'transitionProperty'.
+    // See https://developer.mozilla.org/en/CSS/CSS_transitions#Properties_that_can_be_animated
+    propertyMap: {
+      marginLeft    : 'margin',
+      marginRight   : 'margin',
+      marginBottom  : 'margin',
+      marginTop     : 'margin',
+      paddingLeft   : 'padding',
+      paddingRight  : 'padding',
+      paddingBottom : 'padding',
+      paddingTop    : 'padding'
+    },
+
+    // Will simply transition "instantly" if false
+    enabled: true,
+
+    // Set this to false if you don't want to use the transition end property.
+    useTransitionEnd: false
+  };
+
+  var div = document.createElement('div');
+  var support = {};
+
+  // Helper function to get the proper vendor property name.
+  // (`transition` => `WebkitTransition`)
+  function getVendorPropertyName(prop) {
+    // Handle unprefixed versions (FF16+, for example)
+    if (prop in div.style) return prop;
+
+    var prefixes = ['Moz', 'Webkit', 'O', 'ms'];
+    var prop_ = prop.charAt(0).toUpperCase() + prop.substr(1);
+
+    if (prop in div.style) { return prop; }
+
+    for (var i=0; i<prefixes.length; ++i) {
+      var vendorProp = prefixes[i] + prop_;
+      if (vendorProp in div.style) { return vendorProp; }
+    }
+  }
+
+  // Helper function to check if transform3D is supported.
+  // Should return true for Webkits and Firefox 10+.
+  function checkTransform3dSupport() {
+    div.style[support.transform] = '';
+    div.style[support.transform] = 'rotateY(90deg)';
+    return div.style[support.transform] !== '';
+  }
+
+  var isChrome = navigator.userAgent.toLowerCase().indexOf('chrome') > -1;
+
+  // Check for the browser's transitions support.
+  support.transition      = getVendorPropertyName('transition');
+  support.transitionDelay = getVendorPropertyName('transitionDelay');
+  support.transform       = getVendorPropertyName('transform');
+  support.transformOrigin = getVendorPropertyName('transformOrigin');
+  support.transform3d     = checkTransform3dSupport();
+
+  var eventNames = {
+    'transition':       'transitionEnd',
+    'MozTransition':    'transitionend',
+    'OTransition':      'oTransitionEnd',
+    'WebkitTransition': 'webkitTransitionEnd',
+    'msTransition':     'MSTransitionEnd'
+  };
+
+  // Detect the 'transitionend' event needed.
+  var transitionEnd = support.transitionEnd = eventNames[support.transition] || null;
+
+  // Populate jQuery's `$.support` with the vendor prefixes we know.
+  // As per [jQuery's cssHooks documentation](http://api.jquery.com/jQuery.cssHooks/),
+  // we set $.support.transition to a string of the actual property name used.
+  for (var key in support) {
+    if (support.hasOwnProperty(key) && typeof $.support[key] === 'undefined') {
+      $.support[key] = support[key];
+    }
+  }
+
+  // Avoid memory leak in IE.
+  div = null;
+
+  // ## $.cssEase
+  // List of easing aliases that you can use with `$.fn.transition`.
+  $.cssEase = {
+    '_default':       'ease',
+    'in':             'ease-in',
+    'out':            'ease-out',
+    'in-out':         'ease-in-out',
+    'snap':           'cubic-bezier(0,1,.5,1)',
+    // Penner equations
+    'easeOutCubic':   'cubic-bezier(.215,.61,.355,1)',
+    'easeInOutCubic': 'cubic-bezier(.645,.045,.355,1)',
+    'easeInCirc':     'cubic-bezier(.6,.04,.98,.335)',
+    'easeOutCirc':    'cubic-bezier(.075,.82,.165,1)',
+    'easeInOutCirc':  'cubic-bezier(.785,.135,.15,.86)',
+    'easeInExpo':     'cubic-bezier(.95,.05,.795,.035)',
+    'easeOutExpo':    'cubic-bezier(.19,1,.22,1)',
+    'easeInOutExpo':  'cubic-bezier(1,0,0,1)',
+    'easeInQuad':     'cubic-bezier(.55,.085,.68,.53)',
+    'easeOutQuad':    'cubic-bezier(.25,.46,.45,.94)',
+    'easeInOutQuad':  'cubic-bezier(.455,.03,.515,.955)',
+    'easeInQuart':    'cubic-bezier(.895,.03,.685,.22)',
+    'easeOutQuart':   'cubic-bezier(.165,.84,.44,1)',
+    'easeInOutQuart': 'cubic-bezier(.77,0,.175,1)',
+    'easeInQuint':    'cubic-bezier(.755,.05,.855,.06)',
+    'easeOutQuint':   'cubic-bezier(.23,1,.32,1)',
+    'easeInOutQuint': 'cubic-bezier(.86,0,.07,1)',
+    'easeInSine':     'cubic-bezier(.47,0,.745,.715)',
+    'easeOutSine':    'cubic-bezier(.39,.575,.565,1)',
+    'easeInOutSine':  'cubic-bezier(.445,.05,.55,.95)',
+    'easeInBack':     'cubic-bezier(.6,-.28,.735,.045)',
+    'easeOutBack':    'cubic-bezier(.175, .885,.32,1.275)',
+    'easeInOutBack':  'cubic-bezier(.68,-.55,.265,1.55)'
+  };
+
+  // ## 'transform' CSS hook
+  // Allows you to use the `transform` property in CSS.
+  //
+  //     $("#hello").css({ transform: "rotate(90deg)" });
+  //
+  //     $("#hello").css('transform');
+  //     //=> { rotate: '90deg' }
+  //
+  $.cssHooks['transit:transform'] = {
+    // The getter returns a `Transform` object.
+    get: function(elem) {
+      return $(elem).data('transform') || new Transform();
+    },
+
+    // The setter accepts a `Transform` object or a string.
+    set: function(elem, v) {
+      var value = v;
+
+      if (!(value instanceof Transform)) {
+        value = new Transform(value);
+      }
+
+      // We've seen the 3D version of Scale() not work in Chrome when the
+      // element being scaled extends outside of the viewport.  Thus, we're
+      // forcing Chrome to not use the 3d transforms as well.  Not sure if
+      // translate is affectede, but not risking it.  Detection code from
+      // http://davidwalsh.name/detecting-google-chrome-javascript
+      if (support.transform === 'WebkitTransform' && !isChrome) {
+        elem.style[support.transform] = value.toString(true);
+      } else {
+        elem.style[support.transform] = value.toString();
+      }
+
+      $(elem).data('transform', value);
+    }
+  };
+
+  // Add a CSS hook for `.css({ transform: '...' })`.
+  // In jQuery 1.8+, this will intentionally override the default `transform`
+  // CSS hook so it'll play well with Transit. (see issue #62)
+  $.cssHooks.transform = {
+    set: $.cssHooks['transit:transform'].set
+  };
+
+  // jQuery 1.8+ supports prefix-free transitions, so these polyfills will not
+  // be necessary.
+  if ($.fn.jquery < "1.8") {
+    // ## 'transformOrigin' CSS hook
+    // Allows the use for `transformOrigin` to define where scaling and rotation
+    // is pivoted.
+    //
+    //     $("#hello").css({ transformOrigin: '0 0' });
+    //
+    $.cssHooks.transformOrigin = {
+      get: function(elem) {
+        return elem.style[support.transformOrigin];
+      },
+      set: function(elem, value) {
+        elem.style[support.transformOrigin] = value;
+      }
+    };
+
+    // ## 'transition' CSS hook
+    // Allows you to use the `transition` property in CSS.
+    //
+    //     $("#hello").css({ transition: 'all 0 ease 0' });
+    //
+    $.cssHooks.transition = {
+      get: function(elem) {
+        return elem.style[support.transition];
+      },
+      set: function(elem, value) {
+        elem.style[support.transition] = value;
+      }
+    };
+  }
+
+  // ## Other CSS hooks
+  // Allows you to rotate, scale and translate.
+  registerCssHook('scale');
+  registerCssHook('translate');
+  registerCssHook('rotate');
+  registerCssHook('rotateX');
+  registerCssHook('rotateY');
+  registerCssHook('rotate3d');
+  registerCssHook('perspective');
+  registerCssHook('skewX');
+  registerCssHook('skewY');
+  registerCssHook('x', true);
+  registerCssHook('y', true);
+
+  // ## Transform class
+  // This is the main class of a transformation property that powers
+  // `$.fn.css({ transform: '...' })`.
+  //
+  // This is, in essence, a dictionary object with key/values as `-transform`
+  // properties.
+  //
+  //     var t = new Transform("rotate(90) scale(4)");
+  //
+  //     t.rotate             //=> "90deg"
+  //     t.scale              //=> "4,4"
+  //
+  // Setters are accounted for.
+  //
+  //     t.set('rotate', 4)
+  //     t.rotate             //=> "4deg"
+  //
+  // Convert it to a CSS string using the `toString()` and `toString(true)` (for WebKit)
+  // functions.
+  //
+  //     t.toString()         //=> "rotate(90deg) scale(4,4)"
+  //     t.toString(true)     //=> "rotate(90deg) scale3d(4,4,0)" (WebKit version)
+  //
+  function Transform(str) {
+    if (typeof str === 'string') { this.parse(str); }
+    return this;
+  }
+
+  Transform.prototype = {
+    // ### setFromString()
+    // Sets a property from a string.
+    //
+    //     t.setFromString('scale', '2,4');
+    //     // Same as set('scale', '2', '4');
+    //
+    setFromString: function(prop, val) {
+      var args =
+        (typeof val === 'string')  ? val.split(',') :
+        (val.constructor === Array) ? val :
+        [ val ];
+
+      args.unshift(prop);
+
+      Transform.prototype.set.apply(this, args);
+    },
+
+    // ### set()
+    // Sets a property.
+    //
+    //     t.set('scale', 2, 4);
+    //
+    set: function(prop) {
+      var args = Array.prototype.slice.apply(arguments, [1]);
+      if (this.setter[prop]) {
+        this.setter[prop].apply(this, args);
+      } else {
+        this[prop] = args.join(',');
+      }
+    },
+
+    get: function(prop) {
+      if (this.getter[prop]) {
+        return this.getter[prop].apply(this);
+      } else {
+        return this[prop] || 0;
+      }
+    },
+
+    setter: {
+      // ### rotate
+      //
+      //     .css({ rotate: 30 })
+      //     .css({ rotate: "30" })
+      //     .css({ rotate: "30deg" })
+      //     .css({ rotate: "30deg" })
+      //
+      rotate: function(theta) {
+        this.rotate = unit(theta, 'deg');
+      },
+
+      rotateX: function(theta) {
+        this.rotateX = unit(theta, 'deg');
+      },
+
+      rotateY: function(theta) {
+        this.rotateY = unit(theta, 'deg');
+      },
+
+      // ### scale
+      //
+      //     .css({ scale: 9 })      //=> "scale(9,9)"
+      //     .css({ scale: '3,2' })  //=> "scale(3,2)"
+      //
+      scale: function(x, y) {
+        if (y === undefined) { y = x; }
+        this.scale = x + "," + y;
+      },
+
+      // ### skewX + skewY
+      skewX: function(x) {
+        this.skewX = unit(x, 'deg');
+      },
+
+      skewY: function(y) {
+        this.skewY = unit(y, 'deg');
+      },
+
+      // ### perspectvie
+      perspective: function(dist) {
+        this.perspective = unit(dist, 'px');
+      },
+
+      // ### x / y
+      // Translations. Notice how this keeps the other value.
+      //
+      //     .css({ x: 4 })       //=> "translate(4px, 0)"
+      //     .css({ y: 10 })      //=> "translate(4px, 10px)"
+      //
+      x: function(x) {
+        this.set('translate', x, null);
+      },
+
+      y: function(y) {
+        this.set('translate', null, y);
+      },
+
+      // ### translate
+      // Notice how this keeps the other value.
+      //
+      //     .css({ translate: '2, 5' })    //=> "translate(2px, 5px)"
+      //
+      translate: function(x, y) {
+        if (this._translateX === undefined) { this._translateX = 0; }
+        if (this._translateY === undefined) { this._translateY = 0; }
+
+        if (x !== null && x !== undefined) { this._translateX = unit(x, 'px'); }
+        if (y !== null && y !== undefined) { this._translateY = unit(y, 'px'); }
+
+        this.translate = this._translateX + "," + this._translateY;
+      }
+    },
+
+    getter: {
+      x: function() {
+        return this._translateX || 0;
+      },
+
+      y: function() {
+        return this._translateY || 0;
+      },
+
+      scale: function() {
+        var s = (this.scale || "1,1").split(',');
+        if (s[0]) { s[0] = parseFloat(s[0]); }
+        if (s[1]) { s[1] = parseFloat(s[1]); }
+
+        // "2.5,2.5" => 2.5
+        // "2.5,1" => [2.5,1]
+        return (s[0] === s[1]) ? s[0] : s;
+      },
+
+      rotate3d: function() {
+        var s = (this.rotate3d || "0,0,0,0deg").split(',');
+        for (var i=0; i<=3; ++i) {
+          if (s[i]) { s[i] = parseFloat(s[i]); }
+        }
+        if (s[3]) { s[3] = unit(s[3], 'deg'); }
+
+        return s;
+      }
+    },
+
+    // ### parse()
+    // Parses from a string. Called on constructor.
+    parse: function(str) {
+      var self = this;
+      str.replace(/([a-zA-Z0-9]+)\((.*?)\)/g, function(x, prop, val) {
+        self.setFromString(prop, val);
+      });
+    },
+
+    // ### toString()
+    // Converts to a `transition` CSS property string. If `use3d` is given,
+    // it converts to a `-webkit-transition` CSS property string instead.
+    toString: function(use3d) {
+      var re = [];
+
+      for (var i in this) {
+        if (this.hasOwnProperty(i)) {
+          // Don't use 3D transformations if the browser can't support it.
+          if ((!support.transform3d) && (
+            (i === 'rotateX') ||
+            (i === 'rotateY') ||
+            (i === 'perspective') ||
+            (i === 'transformOrigin'))) { continue; }
+
+          if (i[0] !== '_') {
+            if (use3d && (i === 'scale')) {
+              re.push(i + "3d(" + this[i] + ",1)");
+            } else if (use3d && (i === 'translate')) {
+              re.push(i + "3d(" + this[i] + ",0)");
+            } else {
+              re.push(i + "(" + this[i] + ")");
+            }
+          }
+        }
+      }
+
+      return re.join(" ");
+    }
+  };
+
+  function callOrQueue(self, queue, fn) {
+    if (queue === true) {
+      self.queue(fn);
+    } else if (queue) {
+      self.queue(queue, fn);
+    } else {
+      fn();
+    }
+  }
+
+  // ### getProperties(dict)
+  // Returns properties (for `transition-property`) for dictionary `props`. The
+  // value of `props` is what you would expect in `$.css(...)`.
+  function getProperties(props) {
+    var re = [];
+
+    $.each(props, function(key) {
+      key = $.camelCase(key); // Convert "text-align" => "textAlign"
+      key = $.transit.propertyMap[key] || $.cssProps[key] || key;
+      key = uncamel(key); // Convert back to dasherized
+
+      if ($.inArray(key, re) === -1) { re.push(key); }
+    });
+
+    return re;
+  }
+
+  // ### getTransition()
+  // Returns the transition string to be used for the `transition` CSS property.
+  //
+  // Example:
+  //
+  //     getTransition({ opacity: 1, rotate: 30 }, 500, 'ease');
+  //     //=> 'opacity 500ms ease, -webkit-transform 500ms ease'
+  //
+  function getTransition(properties, duration, easing, delay) {
+    // Get the CSS properties needed.
+    var props = getProperties(properties);
+
+    // Account for aliases (`in` => `ease-in`).
+    if ($.cssEase[easing]) { easing = $.cssEase[easing]; }
+
+    // Build the duration/easing/delay attributes for it.
+    var attribs = '' + toMS(duration) + ' ' + easing;
+    if (parseInt(delay, 10) > 0) { attribs += ' ' + toMS(delay); }
+
+    // For more properties, add them this way:
+    // "margin 200ms ease, padding 200ms ease, ..."
+    var transitions = [];
+    $.each(props, function(i, name) {
+      transitions.push(name + ' ' + attribs);
+    });
+
+    return transitions.join(', ');
+  }
+
+  // ## $.fn.transition
+  // Works like $.fn.animate(), but uses CSS transitions.
+  //
+  //     $("...").transition({ opacity: 0.1, scale: 0.3 });
+  //
+  //     // Specific duration
+  //     $("...").transition({ opacity: 0.1, scale: 0.3 }, 500);
+  //
+  //     // With duration and easing
+  //     $("...").transition({ opacity: 0.1, scale: 0.3 }, 500, 'in');
+  //
+  //     // With callback
+  //     $("...").transition({ opacity: 0.1, scale: 0.3 }, function() { ... });
+  //
+  //     // With everything
+  //     $("...").transition({ opacity: 0.1, scale: 0.3 }, 500, 'in', function() { ... });
+  //
+  //     // Alternate syntax
+  //     $("...").transition({
+  //       opacity: 0.1,
+  //       duration: 200,
+  //       delay: 40,
+  //       easing: 'in',
+  //       complete: function() { /* ... */ }
+  //      });
+  //
+  $.fn.transition = $.fn.transit = function(properties, duration, easing, callback) {
+    var self  = this;
+    var delay = 0;
+    var queue = true;
+
+    // Account for `.transition(properties, callback)`.
+    if (typeof duration === 'function') {
+      callback = duration;
+      duration = undefined;
+    }
+
+    // Account for `.transition(properties, duration, callback)`.
+    if (typeof easing === 'function') {
+      callback = easing;
+      easing = undefined;
+    }
+
+    // Alternate syntax.
+    if (typeof properties.easing !== 'undefined') {
+      easing = properties.easing;
+      delete properties.easing;
+    }
+
+    if (typeof properties.duration !== 'undefined') {
+      duration = properties.duration;
+      delete properties.duration;
+    }
+
+    if (typeof properties.complete !== 'undefined') {
+      callback = properties.complete;
+      delete properties.complete;
+    }
+
+    if (typeof properties.queue !== 'undefined') {
+      queue = properties.queue;
+      delete properties.queue;
+    }
+
+    if (typeof properties.delay !== 'undefined') {
+      delay = properties.delay;
+      delete properties.delay;
+    }
+
+    // Set defaults. (`400` duration, `ease` easing)
+    if (typeof duration === 'undefined') { duration = $.fx.speeds._default; }
+    if (typeof easing === 'undefined')   { easing = $.cssEase._default; }
+
+    duration = toMS(duration);
+
+    // Build the `transition` property.
+    var transitionValue = getTransition(properties, duration, easing, delay);
+
+    // Compute delay until callback.
+    // If this becomes 0, don't bother setting the transition property.
+    var work = $.transit.enabled && support.transition;
+    var i = work ? (parseInt(duration, 10) + parseInt(delay, 10)) : 0;
+
+    // If there's nothing to do...
+    if (i === 0) {
+      var fn = function(next) {
+        self.css(properties);
+        if (callback) { callback.apply(self); }
+        if (next) { next(); }
+      };
+
+      callOrQueue(self, queue, fn);
+      return self;
+    }
+
+    // Save the old transitions of each element so we can restore it later.
+    var oldTransitions = {};
+
+    var run = function(nextCall) {
+      var bound = false;
+
+      // Prepare the callback.
+      var cb = function() {
+        if (bound) { self.unbind(transitionEnd, cb); }
+
+        if (i > 0) {
+          self.each(function() {
+            this.style[support.transition] = (oldTransitions[this] || null);
+          });
+        }
+
+        if (typeof callback === 'function') { callback.apply(self); }
+        if (typeof nextCall === 'function') { nextCall(); }
+      };
+
+      if ((i > 0) && (transitionEnd) && ($.transit.useTransitionEnd)) {
+        // Use the 'transitionend' event if it's available.
+        bound = true;
+        self.bind(transitionEnd, cb);
+      } else {
+        // Fallback to timers if the 'transitionend' event isn't supported.
+        window.setTimeout(cb, i);
+      }
+
+      // Apply transitions.
+      self.each(function() {
+        if (i > 0) {
+          this.style[support.transition] = transitionValue;
+        }
+        $(this).css(properties);
+      });
+    };
+
+    // Defer running. This allows the browser to paint any pending CSS it hasn't
+    // painted yet before doing the transitions.
+    var deferredRun = function(next) {
+      var i = 0;
+
+      // Durations that are too slow will get transitions mixed up.
+      // (Tested on Mac/FF 7.0.1)
+      if ((support.transition === 'MozTransition') && (i < 25)) { i = 25; }
+
+      window.setTimeout(function() { run(next); }, i);
+    };
+
+    // Use jQuery's fx queue.
+    callOrQueue(self, queue, deferredRun);
+
+    // Chainability.
+    return this;
+  };
+
+  function registerCssHook(prop, isPixels) {
+    // For certain properties, the 'px' should not be implied.
+    if (!isPixels) { $.cssNumber[prop] = true; }
+
+    $.transit.propertyMap[prop] = support.transform;
+
+    $.cssHooks[prop] = {
+      get: function(elem) {
+        var t = $(elem).css('transit:transform');
+        return t.get(prop);
+      },
+
+      set: function(elem, value) {
+        var t = $(elem).css('transit:transform');
+        t.setFromString(prop, value);
+
+        $(elem).css({ 'transit:transform': t });
+      }
+    };
+
+  }
+
+  // ### uncamel(str)
+  // Converts a camelcase string to a dasherized string.
+  // (`marginLeft` => `margin-left`)
+  function uncamel(str) {
+    return str.replace(/([A-Z])/g, function(letter) { return '-' + letter.toLowerCase(); });
+  }
+
+  // ### unit(number, unit)
+  // Ensures that number `number` has a unit. If no unit is found, assume the
+  // default is `unit`.
+  //
+  //     unit(2, 'px')          //=> "2px"
+  //     unit("30deg", 'rad')   //=> "30deg"
+  //
+  function unit(i, units) {
+    if ((typeof i === "string") && (!i.match(/^[\-0-9\.]+$/))) {
+      return i;
+    } else {
+      return "" + i + units;
+    }
+  }
+
+  // ### toMS(duration)
+  // Converts given `duration` to a millisecond string.
+  //
+  //     toMS('fast')   //=> '400ms'
+  //     toMS(10)       //=> '10ms'
+  //
+  function toMS(duration) {
+    var i = duration;
+
+    // Allow for string durations like 'fast'.
+    if ($.fx.speeds[i]) { i = $.fx.speeds[i]; }
+
+    return unit(i, 'ms');
+  }
+
+  // Export some functions for testable-ness.
+  $.transit.getTransitionValue = getTransition;
+})(jQuery);
diff --git a/module/web/static/js/libs/jqueryui/core.js b/module/web/static/js/libs/jqueryui/core.js
new file mode 100644
index 000000000..4fdeb9277
--- /dev/null
+++ b/module/web/static/js/libs/jqueryui/core.js
@@ -0,0 +1,327 @@
+define(['jquery'], function (jQuery) {
+/*!
+ * jQuery UI Core 1.10.1
+ * http://jqueryui.com
+ *
+ * Copyright 2013 jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ *
+ * http://api.jqueryui.com/category/ui-core/
+ */
+(function( $, undefined ) {
+
+var uuid = 0,
+	runiqueId = /^ui-id-\d+$/;
+
+// prevent duplicate loading
+// this is only a problem because we proxy existing functions
+// and we don't want to double proxy them
+$.ui = $.ui || {};
+if ( $.ui.version ) {
+	return;
+}
+
+$.extend( $.ui, {
+	version: "1.10.1",
+
+	keyCode: {
+		BACKSPACE: 8,
+		COMMA: 188,
+		DELETE: 46,
+		DOWN: 40,
+		END: 35,
+		ENTER: 13,
+		ESCAPE: 27,
+		HOME: 36,
+		LEFT: 37,
+		NUMPAD_ADD: 107,
+		NUMPAD_DECIMAL: 110,
+		NUMPAD_DIVIDE: 111,
+		NUMPAD_ENTER: 108,
+		NUMPAD_MULTIPLY: 106,
+		NUMPAD_SUBTRACT: 109,
+		PAGE_DOWN: 34,
+		PAGE_UP: 33,
+		PERIOD: 190,
+		RIGHT: 39,
+		SPACE: 32,
+		TAB: 9,
+		UP: 38
+	}
+});
+
+// plugins
+$.fn.extend({
+	_focus: $.fn.focus,
+	focus: function( delay, fn ) {
+		return typeof delay === "number" ?
+			this.each(function() {
+				var elem = this;
+				setTimeout(function() {
+					$( elem ).focus();
+					if ( fn ) {
+						fn.call( elem );
+					}
+				}, delay );
+			}) :
+			this._focus.apply( this, arguments );
+	},
+
+	scrollParent: function() {
+		var scrollParent;
+		if (($.ui.ie && (/(static|relative)/).test(this.css("position"))) || (/absolute/).test(this.css("position"))) {
+			scrollParent = this.parents().filter(function() {
+				return (/(relative|absolute|fixed)/).test($.css(this,"position")) && (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x"));
+			}).eq(0);
+		} else {
+			scrollParent = this.parents().filter(function() {
+				return (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x"));
+			}).eq(0);
+		}
+
+		return (/fixed/).test(this.css("position")) || !scrollParent.length ? $(document) : scrollParent;
+	},
+
+	zIndex: function( zIndex ) {
+		if ( zIndex !== undefined ) {
+			return this.css( "zIndex", zIndex );
+		}
+
+		if ( this.length ) {
+			var elem = $( this[ 0 ] ), position, value;
+			while ( elem.length && elem[ 0 ] !== document ) {
+				// Ignore z-index if position is set to a value where z-index is ignored by the browser
+				// This makes behavior of this function consistent across browsers
+				// WebKit always returns auto if the element is positioned
+				position = elem.css( "position" );
+				if ( position === "absolute" || position === "relative" || position === "fixed" ) {
+					// IE returns 0 when zIndex is not specified
+					// other browsers return a string
+					// we ignore the case of nested elements with an explicit value of 0
+					// <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
+					value = parseInt( elem.css( "zIndex" ), 10 );
+					if ( !isNaN( value ) && value !== 0 ) {
+						return value;
+					}
+				}
+				elem = elem.parent();
+			}
+		}
+
+		return 0;
+	},
+
+	uniqueId: function() {
+		return this.each(function() {
+			if ( !this.id ) {
+				this.id = "ui-id-" + (++uuid);
+			}
+		});
+	},
+
+	removeUniqueId: function() {
+		return this.each(function() {
+			if ( runiqueId.test( this.id ) ) {
+				$( this ).removeAttr( "id" );
+			}
+		});
+	}
+});
+
+// selectors
+function focusable( element, isTabIndexNotNaN ) {
+	var map, mapName, img,
+		nodeName = element.nodeName.toLowerCase();
+	if ( "area" === nodeName ) {
+		map = element.parentNode;
+		mapName = map.name;
+		if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) {
+			return false;
+		}
+		img = $( "img[usemap=#" + mapName + "]" )[0];
+		return !!img && visible( img );
+	}
+	return ( /input|select|textarea|button|object/.test( nodeName ) ?
+		!element.disabled :
+		"a" === nodeName ?
+			element.href || isTabIndexNotNaN :
+			isTabIndexNotNaN) &&
+		// the element and all of its ancestors must be visible
+		visible( element );
+}
+
+function visible( element ) {
+	return $.expr.filters.visible( element ) &&
+		!$( element ).parents().addBack().filter(function() {
+			return $.css( this, "visibility" ) === "hidden";
+		}).length;
+}
+
+$.extend( $.expr[ ":" ], {
+	data: $.expr.createPseudo ?
+		$.expr.createPseudo(function( dataName ) {
+			return function( elem ) {
+				return !!$.data( elem, dataName );
+			};
+		}) :
+		// support: jQuery <1.8
+		function( elem, i, match ) {
+			return !!$.data( elem, match[ 3 ] );
+		},
+
+	focusable: function( element ) {
+		return focusable( element, !isNaN( $.attr( element, "tabindex" ) ) );
+	},
+
+	tabbable: function( element ) {
+		var tabIndex = $.attr( element, "tabindex" ),
+			isTabIndexNaN = isNaN( tabIndex );
+		return ( isTabIndexNaN || tabIndex >= 0 ) && focusable( element, !isTabIndexNaN );
+	}
+});
+
+// support: jQuery <1.8
+if ( !$( "<a>" ).outerWidth( 1 ).jquery ) {
+	$.each( [ "Width", "Height" ], function( i, name ) {
+		var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ],
+			type = name.toLowerCase(),
+			orig = {
+				innerWidth: $.fn.innerWidth,
+				innerHeight: $.fn.innerHeight,
+				outerWidth: $.fn.outerWidth,
+				outerHeight: $.fn.outerHeight
+			};
+
+		function reduce( elem, size, border, margin ) {
+			$.each( side, function() {
+				size -= parseFloat( $.css( elem, "padding" + this ) ) || 0;
+				if ( border ) {
+					size -= parseFloat( $.css( elem, "border" + this + "Width" ) ) || 0;
+				}
+				if ( margin ) {
+					size -= parseFloat( $.css( elem, "margin" + this ) ) || 0;
+				}
+			});
+			return size;
+		}
+
+		$.fn[ "inner" + name ] = function( size ) {
+			if ( size === undefined ) {
+				return orig[ "inner" + name ].call( this );
+			}
+
+			return this.each(function() {
+				$( this ).css( type, reduce( this, size ) + "px" );
+			});
+		};
+
+		$.fn[ "outer" + name] = function( size, margin ) {
+			if ( typeof size !== "number" ) {
+				return orig[ "outer" + name ].call( this, size );
+			}
+
+			return this.each(function() {
+				$( this).css( type, reduce( this, size, true, margin ) + "px" );
+			});
+		};
+	});
+}
+
+// support: jQuery <1.8
+if ( !$.fn.addBack ) {
+	$.fn.addBack = function( selector ) {
+		return this.add( selector == null ?
+			this.prevObject : this.prevObject.filter( selector )
+		);
+	};
+}
+
+// support: jQuery 1.6.1, 1.6.2 (http://bugs.jquery.com/ticket/9413)
+if ( $( "<a>" ).data( "a-b", "a" ).removeData( "a-b" ).data( "a-b" ) ) {
+	$.fn.removeData = (function( removeData ) {
+		return function( key ) {
+			if ( arguments.length ) {
+				return removeData.call( this, $.camelCase( key ) );
+			} else {
+				return removeData.call( this );
+			}
+		};
+	})( $.fn.removeData );
+}
+
+
+
+
+
+// deprecated
+$.ui.ie = !!/msie [\w.]+/.exec( navigator.userAgent.toLowerCase() );
+
+$.support.selectstart = "onselectstart" in document.createElement( "div" );
+$.fn.extend({
+	disableSelection: function() {
+		return this.bind( ( $.support.selectstart ? "selectstart" : "mousedown" ) +
+			".ui-disableSelection", function( event ) {
+				event.preventDefault();
+			});
+	},
+
+	enableSelection: function() {
+		return this.unbind( ".ui-disableSelection" );
+	}
+});
+
+$.extend( $.ui, {
+	// $.ui.plugin is deprecated.  Use the proxy pattern instead.
+	plugin: {
+		add: function( module, option, set ) {
+			var i,
+				proto = $.ui[ module ].prototype;
+			for ( i in set ) {
+				proto.plugins[ i ] = proto.plugins[ i ] || [];
+				proto.plugins[ i ].push( [ option, set[ i ] ] );
+			}
+		},
+		call: function( instance, name, args ) {
+			var i,
+				set = instance.plugins[ name ];
+			if ( !set || !instance.element[ 0 ].parentNode || instance.element[ 0 ].parentNode.nodeType === 11 ) {
+				return;
+			}
+
+			for ( i = 0; i < set.length; i++ ) {
+				if ( instance.options[ set[ i ][ 0 ] ] ) {
+					set[ i ][ 1 ].apply( instance.element, args );
+				}
+			}
+		}
+	},
+
+	// only used by resizable
+	hasScroll: function( el, a ) {
+
+		//If overflow is hidden, the element might have extra content, but the user wants to hide it
+		if ( $( el ).css( "overflow" ) === "hidden") {
+			return false;
+		}
+
+		var scroll = ( a && a === "left" ) ? "scrollLeft" : "scrollTop",
+			has = false;
+
+		if ( el[ scroll ] > 0 ) {
+			return true;
+		}
+
+		// TODO: determine which cases actually cause this to happen
+		// if the element doesn't have the scroll set, see if it's possible to
+		// set the scroll
+		el[ scroll ] = 1;
+		has = ( el[ scroll ] > 0 );
+		el[ scroll ] = 0;
+		return has;
+	}
+});
+
+})( jQuery );
+
+});
\ No newline at end of file
diff --git a/module/web/static/js/libs/jqueryui/draggable.js b/module/web/static/js/libs/jqueryui/draggable.js
new file mode 100644
index 000000000..43604c273
--- /dev/null
+++ b/module/web/static/js/libs/jqueryui/draggable.js
@@ -0,0 +1,946 @@
+define(['jquery','./core','./mouse','./widget'], function (jQuery) {
+/*!
+ * jQuery UI Draggable 1.10.1
+ * http://jqueryui.com
+ *
+ * Copyright 2013 jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ *
+ * http://api.jqueryui.com/draggable/
+ *
+ * Depends:
+ *	jquery.ui.core.js
+ *	jquery.ui.mouse.js
+ *	jquery.ui.widget.js
+ */
+(function( $, undefined ) {
+
+$.widget("ui.draggable", $.ui.mouse, {
+	version: "1.10.1",
+	widgetEventPrefix: "drag",
+	options: {
+		addClasses: true,
+		appendTo: "parent",
+		axis: false,
+		connectToSortable: false,
+		containment: false,
+		cursor: "auto",
+		cursorAt: false,
+		grid: false,
+		handle: false,
+		helper: "original",
+		iframeFix: false,
+		opacity: false,
+		refreshPositions: false,
+		revert: false,
+		revertDuration: 500,
+		scope: "default",
+		scroll: true,
+		scrollSensitivity: 20,
+		scrollSpeed: 20,
+		snap: false,
+		snapMode: "both",
+		snapTolerance: 20,
+		stack: false,
+		zIndex: false,
+
+		// callbacks
+		drag: null,
+		start: null,
+		stop: null
+	},
+	_create: function() {
+
+		if (this.options.helper === "original" && !(/^(?:r|a|f)/).test(this.element.css("position"))) {
+			this.element[0].style.position = "relative";
+		}
+		if (this.options.addClasses){
+			this.element.addClass("ui-draggable");
+		}
+		if (this.options.disabled){
+			this.element.addClass("ui-draggable-disabled");
+		}
+
+		this._mouseInit();
+
+	},
+
+	_destroy: function() {
+		this.element.removeClass( "ui-draggable ui-draggable-dragging ui-draggable-disabled" );
+		this._mouseDestroy();
+	},
+
+	_mouseCapture: function(event) {
+
+		var o = this.options;
+
+		// among others, prevent a drag on a resizable-handle
+		if (this.helper || o.disabled || $(event.target).closest(".ui-resizable-handle").length > 0) {
+			return false;
+		}
+
+		//Quit if we're not on a valid handle
+		this.handle = this._getHandle(event);
+		if (!this.handle) {
+			return false;
+		}
+
+		$(o.iframeFix === true ? "iframe" : o.iframeFix).each(function() {
+			$("<div class='ui-draggable-iframeFix' style='background: #fff;'></div>")
+			.css({
+				width: this.offsetWidth+"px", height: this.offsetHeight+"px",
+				position: "absolute", opacity: "0.001", zIndex: 1000
+			})
+			.css($(this).offset())
+			.appendTo("body");
+		});
+
+		return true;
+
+	},
+
+	_mouseStart: function(event) {
+
+		var o = this.options;
+
+		//Create and append the visible helper
+		this.helper = this._createHelper(event);
+
+		this.helper.addClass("ui-draggable-dragging");
+
+		//Cache the helper size
+		this._cacheHelperProportions();
+
+		//If ddmanager is used for droppables, set the global draggable
+		if($.ui.ddmanager) {
+			$.ui.ddmanager.current = this;
+		}
+
+		/*
+		 * - Position generation -
+		 * This block generates everything position related - it's the core of draggables.
+		 */
+
+		//Cache the margins of the original element
+		this._cacheMargins();
+
+		//Store the helper's css position
+		this.cssPosition = this.helper.css("position");
+		this.scrollParent = this.helper.scrollParent();
+
+		//The element's absolute position on the page minus margins
+		this.offset = this.positionAbs = this.element.offset();
+		this.offset = {
+			top: this.offset.top - this.margins.top,
+			left: this.offset.left - this.margins.left
+		};
+
+		$.extend(this.offset, {
+			click: { //Where the click happened, relative to the element
+				left: event.pageX - this.offset.left,
+				top: event.pageY - this.offset.top
+			},
+			parent: this._getParentOffset(),
+			relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
+		});
+
+		//Generate the original position
+		this.originalPosition = this.position = this._generatePosition(event);
+		this.originalPageX = event.pageX;
+		this.originalPageY = event.pageY;
+
+		//Adjust the mouse offset relative to the helper if "cursorAt" is supplied
+		(o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
+
+		//Set a containment if given in the options
+		if(o.containment) {
+			this._setContainment();
+		}
+
+		//Trigger event + callbacks
+		if(this._trigger("start", event) === false) {
+			this._clear();
+			return false;
+		}
+
+		//Recache the helper size
+		this._cacheHelperProportions();
+
+		//Prepare the droppable offsets
+		if ($.ui.ddmanager && !o.dropBehaviour) {
+			$.ui.ddmanager.prepareOffsets(this, event);
+		}
+
+
+		this._mouseDrag(event, true); //Execute the drag once - this causes the helper not to be visible before getting its correct position
+
+		//If the ddmanager is used for droppables, inform the manager that dragging has started (see #5003)
+		if ( $.ui.ddmanager ) {
+			$.ui.ddmanager.dragStart(this, event);
+		}
+
+		return true;
+	},
+
+	_mouseDrag: function(event, noPropagation) {
+
+		//Compute the helpers position
+		this.position = this._generatePosition(event);
+		this.positionAbs = this._convertPositionTo("absolute");
+
+		//Call plugins and callbacks and use the resulting position if something is returned
+		if (!noPropagation) {
+			var ui = this._uiHash();
+			if(this._trigger("drag", event, ui) === false) {
+				this._mouseUp({});
+				return false;
+			}
+			this.position = ui.position;
+		}
+
+		if(!this.options.axis || this.options.axis !== "y") {
+			this.helper[0].style.left = this.position.left+"px";
+		}
+		if(!this.options.axis || this.options.axis !== "x") {
+			this.helper[0].style.top = this.position.top+"px";
+		}
+		if($.ui.ddmanager) {
+			$.ui.ddmanager.drag(this, event);
+		}
+
+		return false;
+	},
+
+	_mouseStop: function(event) {
+
+		//If we are using droppables, inform the manager about the drop
+		var element,
+			that = this,
+			elementInDom = false,
+			dropped = false;
+		if ($.ui.ddmanager && !this.options.dropBehaviour) {
+			dropped = $.ui.ddmanager.drop(this, event);
+		}
+
+		//if a drop comes from outside (a sortable)
+		if(this.dropped) {
+			dropped = this.dropped;
+			this.dropped = false;
+		}
+
+		//if the original element is no longer in the DOM don't bother to continue (see #8269)
+		element = this.element[0];
+		while ( element && (element = element.parentNode) ) {
+			if (element === document ) {
+				elementInDom = true;
+			}
+		}
+		if ( !elementInDom && this.options.helper === "original" ) {
+			return false;
+		}
+
+		if((this.options.revert === "invalid" && !dropped) || (this.options.revert === "valid" && dropped) || this.options.revert === true || ($.isFunction(this.options.revert) && this.options.revert.call(this.element, dropped))) {
+			$(this.helper).animate(this.originalPosition, parseInt(this.options.revertDuration, 10), function() {
+				if(that._trigger("stop", event) !== false) {
+					that._clear();
+				}
+			});
+		} else {
+			if(this._trigger("stop", event) !== false) {
+				this._clear();
+			}
+		}
+
+		return false;
+	},
+
+	_mouseUp: function(event) {
+		//Remove frame helpers
+		$("div.ui-draggable-iframeFix").each(function() {
+			this.parentNode.removeChild(this);
+		});
+
+		//If the ddmanager is used for droppables, inform the manager that dragging has stopped (see #5003)
+		if( $.ui.ddmanager ) {
+			$.ui.ddmanager.dragStop(this, event);
+		}
+
+		return $.ui.mouse.prototype._mouseUp.call(this, event);
+	},
+
+	cancel: function() {
+
+		if(this.helper.is(".ui-draggable-dragging")) {
+			this._mouseUp({});
+		} else {
+			this._clear();
+		}
+
+		return this;
+
+	},
+
+	_getHandle: function(event) {
+
+		var handle = !this.options.handle || !$(this.options.handle, this.element).length ? true : false;
+		$(this.options.handle, this.element)
+			.find("*")
+			.addBack()
+			.each(function() {
+				if(this === event.target) {
+					handle = true;
+				}
+			});
+
+		return handle;
+
+	},
+
+	_createHelper: function(event) {
+
+		var o = this.options,
+			helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event])) : (o.helper === "clone" ? this.element.clone().removeAttr("id") : this.element);
+
+		if(!helper.parents("body").length) {
+			helper.appendTo((o.appendTo === "parent" ? this.element[0].parentNode : o.appendTo));
+		}
+
+		if(helper[0] !== this.element[0] && !(/(fixed|absolute)/).test(helper.css("position"))) {
+			helper.css("position", "absolute");
+		}
+
+		return helper;
+
+	},
+
+	_adjustOffsetFromHelper: function(obj) {
+		if (typeof obj === "string") {
+			obj = obj.split(" ");
+		}
+		if ($.isArray(obj)) {
+			obj = {left: +obj[0], top: +obj[1] || 0};
+		}
+		if ("left" in obj) {
+			this.offset.click.left = obj.left + this.margins.left;
+		}
+		if ("right" in obj) {
+			this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
+		}
+		if ("top" in obj) {
+			this.offset.click.top = obj.top + this.margins.top;
+		}
+		if ("bottom" in obj) {
+			this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
+		}
+	},
+
+	_getParentOffset: function() {
+
+		//Get the offsetParent and cache its position
+		this.offsetParent = this.helper.offsetParent();
+		var po = this.offsetParent.offset();
+
+		// This is a special case where we need to modify a offset calculated on start, since the following happened:
+		// 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
+		// 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
+		//    the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
+		if(this.cssPosition === "absolute" && this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) {
+			po.left += this.scrollParent.scrollLeft();
+			po.top += this.scrollParent.scrollTop();
+		}
+
+		//This needs to be actually done for all browsers, since pageX/pageY includes this information
+		//Ugly IE fix
+		if((this.offsetParent[0] === document.body) ||
+			(this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() === "html" && $.ui.ie)) {
+			po = { top: 0, left: 0 };
+		}
+
+		return {
+			top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),
+			left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
+		};
+
+	},
+
+	_getRelativeOffset: function() {
+
+		if(this.cssPosition === "relative") {
+			var p = this.element.position();
+			return {
+				top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(),
+				left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft()
+			};
+		} else {
+			return { top: 0, left: 0 };
+		}
+
+	},
+
+	_cacheMargins: function() {
+		this.margins = {
+			left: (parseInt(this.element.css("marginLeft"),10) || 0),
+			top: (parseInt(this.element.css("marginTop"),10) || 0),
+			right: (parseInt(this.element.css("marginRight"),10) || 0),
+			bottom: (parseInt(this.element.css("marginBottom"),10) || 0)
+		};
+	},
+
+	_cacheHelperProportions: function() {
+		this.helperProportions = {
+			width: this.helper.outerWidth(),
+			height: this.helper.outerHeight()
+		};
+	},
+
+	_setContainment: function() {
+
+		var over, c, ce,
+			o = this.options;
+
+		if(o.containment === "parent") {
+			o.containment = this.helper[0].parentNode;
+		}
+		if(o.containment === "document" || o.containment === "window") {
+			this.containment = [
+				o.containment === "document" ? 0 : $(window).scrollLeft() - this.offset.relative.left - this.offset.parent.left,
+				o.containment === "document" ? 0 : $(window).scrollTop() - this.offset.relative.top - this.offset.parent.top,
+				(o.containment === "document" ? 0 : $(window).scrollLeft()) + $(o.containment === "document" ? document : window).width() - this.helperProportions.width - this.margins.left,
+				(o.containment === "document" ? 0 : $(window).scrollTop()) + ($(o.containment === "document" ? document : window).height() || document.body.parentNode.scrollHeight) - this.helperProportions.height - this.margins.top
+			];
+		}
+
+		if(!(/^(document|window|parent)$/).test(o.containment) && o.containment.constructor !== Array) {
+			c = $(o.containment);
+			ce = c[0];
+
+			if(!ce) {
+				return;
+			}
+
+			over = ($(ce).css("overflow") !== "hidden");
+
+			this.containment = [
+				(parseInt($(ce).css("borderLeftWidth"),10) || 0) + (parseInt($(ce).css("paddingLeft"),10) || 0),
+				(parseInt($(ce).css("borderTopWidth"),10) || 0) + (parseInt($(ce).css("paddingTop"),10) || 0),
+				(over ? Math.max(ce.scrollWidth,ce.offsetWidth) : ce.offsetWidth) - (parseInt($(ce).css("borderLeftWidth"),10) || 0) - (parseInt($(ce).css("paddingRight"),10) || 0) - this.helperProportions.width - this.margins.left - this.margins.right,
+				(over ? Math.max(ce.scrollHeight,ce.offsetHeight) : ce.offsetHeight) - (parseInt($(ce).css("borderTopWidth"),10) || 0) - (parseInt($(ce).css("paddingBottom"),10) || 0) - this.helperProportions.height - this.margins.top  - this.margins.bottom
+			];
+			this.relative_container = c;
+
+		} else if(o.containment.constructor === Array) {
+			this.containment = o.containment;
+		}
+
+	},
+
+	_convertPositionTo: function(d, pos) {
+
+		if(!pos) {
+			pos = this.position;
+		}
+
+		var mod = d === "absolute" ? 1 : -1,
+			scroll = this.cssPosition === "absolute" && !(this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent, scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
+
+		return {
+			top: (
+				pos.top	+																// The absolute mouse position
+				this.offset.relative.top * mod +										// Only for relative positioned nodes: Relative offset from element to offset parent
+				this.offset.parent.top * mod -										// The offsetParent's offset without borders (offset + border)
+				( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ) * mod)
+			),
+			left: (
+				pos.left +																// The absolute mouse position
+				this.offset.relative.left * mod +										// Only for relative positioned nodes: Relative offset from element to offset parent
+				this.offset.parent.left * mod	-										// The offsetParent's offset without borders (offset + border)
+				( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ) * mod)
+			)
+		};
+
+	},
+
+	_generatePosition: function(event) {
+
+		var containment, co, top, left,
+			o = this.options,
+			scroll = this.cssPosition === "absolute" && !(this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent,
+			scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName),
+			pageX = event.pageX,
+			pageY = event.pageY;
+
+		/*
+		 * - Position constraining -
+		 * Constrain the position to a mix of grid, containment.
+		 */
+
+		if(this.originalPosition) { //If we are not dragging yet, we won't check for options
+			if(this.containment) {
+			if (this.relative_container){
+				co = this.relative_container.offset();
+				containment = [ this.containment[0] + co.left,
+					this.containment[1] + co.top,
+					this.containment[2] + co.left,
+					this.containment[3] + co.top ];
+			}
+			else {
+				containment = this.containment;
+			}
+
+				if(event.pageX - this.offset.click.left < containment[0]) {
+					pageX = containment[0] + this.offset.click.left;
+				}
+				if(event.pageY - this.offset.click.top < containment[1]) {
+					pageY = containment[1] + this.offset.click.top;
+				}
+				if(event.pageX - this.offset.click.left > containment[2]) {
+					pageX = containment[2] + this.offset.click.left;
+				}
+				if(event.pageY - this.offset.click.top > containment[3]) {
+					pageY = containment[3] + this.offset.click.top;
+				}
+			}
+
+			if(o.grid) {
+				//Check for grid elements set to 0 to prevent divide by 0 error causing invalid argument errors in IE (see ticket #6950)
+				top = o.grid[1] ? this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1] : this.originalPageY;
+				pageY = containment ? ((top - this.offset.click.top >= containment[1] || top - this.offset.click.top > containment[3]) ? top : ((top - this.offset.click.top >= containment[1]) ? top - o.grid[1] : top + o.grid[1])) : top;
+
+				left = o.grid[0] ? this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0] : this.originalPageX;
+				pageX = containment ? ((left - this.offset.click.left >= containment[0] || left - this.offset.click.left > containment[2]) ? left : ((left - this.offset.click.left >= containment[0]) ? left - o.grid[0] : left + o.grid[0])) : left;
+			}
+
+		}
+
+		return {
+			top: (
+				pageY -																	// The absolute mouse position
+				this.offset.click.top	-												// Click offset (relative to the element)
+				this.offset.relative.top -												// Only for relative positioned nodes: Relative offset from element to offset parent
+				this.offset.parent.top +												// The offsetParent's offset without borders (offset + border)
+				( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ))
+			),
+			left: (
+				pageX -																	// The absolute mouse position
+				this.offset.click.left -												// Click offset (relative to the element)
+				this.offset.relative.left -												// Only for relative positioned nodes: Relative offset from element to offset parent
+				this.offset.parent.left +												// The offsetParent's offset without borders (offset + border)
+				( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ))
+			)
+		};
+
+	},
+
+	_clear: function() {
+		this.helper.removeClass("ui-draggable-dragging");
+		if(this.helper[0] !== this.element[0] && !this.cancelHelperRemoval) {
+			this.helper.remove();
+		}
+		this.helper = null;
+		this.cancelHelperRemoval = false;
+	},
+
+	// From now on bulk stuff - mainly helpers
+
+	_trigger: function(type, event, ui) {
+		ui = ui || this._uiHash();
+		$.ui.plugin.call(this, type, [event, ui]);
+		//The absolute position has to be recalculated after plugins
+		if(type === "drag") {
+			this.positionAbs = this._convertPositionTo("absolute");
+		}
+		return $.Widget.prototype._trigger.call(this, type, event, ui);
+	},
+
+	plugins: {},
+
+	_uiHash: function() {
+		return {
+			helper: this.helper,
+			position: this.position,
+			originalPosition: this.originalPosition,
+			offset: this.positionAbs
+		};
+	}
+
+});
+
+$.ui.plugin.add("draggable", "connectToSortable", {
+	start: function(event, ui) {
+
+		var inst = $(this).data("ui-draggable"), o = inst.options,
+			uiSortable = $.extend({}, ui, { item: inst.element });
+		inst.sortables = [];
+		$(o.connectToSortable).each(function() {
+			var sortable = $.data(this, "ui-sortable");
+			if (sortable && !sortable.options.disabled) {
+				inst.sortables.push({
+					instance: sortable,
+					shouldRevert: sortable.options.revert
+				});
+				sortable.refreshPositions();	// Call the sortable's refreshPositions at drag start to refresh the containerCache since the sortable container cache is used in drag and needs to be up to date (this will ensure it's initialised as well as being kept in step with any changes that might have happened on the page).
+				sortable._trigger("activate", event, uiSortable);
+			}
+		});
+
+	},
+	stop: function(event, ui) {
+
+		//If we are still over the sortable, we fake the stop event of the sortable, but also remove helper
+		var inst = $(this).data("ui-draggable"),
+			uiSortable = $.extend({}, ui, { item: inst.element });
+
+		$.each(inst.sortables, function() {
+			if(this.instance.isOver) {
+
+				this.instance.isOver = 0;
+
+				inst.cancelHelperRemoval = true; //Don't remove the helper in the draggable instance
+				this.instance.cancelHelperRemoval = false; //Remove it in the sortable instance (so sortable plugins like revert still work)
+
+				//The sortable revert is supported, and we have to set a temporary dropped variable on the draggable to support revert: "valid/invalid"
+				if(this.shouldRevert) {
+					this.instance.options.revert = true;
+				}
+
+				//Trigger the stop of the sortable
+				this.instance._mouseStop(event);
+
+				this.instance.options.helper = this.instance.options._helper;
+
+				//If the helper has been the original item, restore properties in the sortable
+				if(inst.options.helper === "original") {
+					this.instance.currentItem.css({ top: "auto", left: "auto" });
+				}
+
+			} else {
+				this.instance.cancelHelperRemoval = false; //Remove the helper in the sortable instance
+				this.instance._trigger("deactivate", event, uiSortable);
+			}
+
+		});
+
+	},
+	drag: function(event, ui) {
+
+		var inst = $(this).data("ui-draggable"), that = this;
+
+		$.each(inst.sortables, function() {
+
+			var innermostIntersecting = false,
+				thisSortable = this;
+
+			//Copy over some variables to allow calling the sortable's native _intersectsWith
+			this.instance.positionAbs = inst.positionAbs;
+			this.instance.helperProportions = inst.helperProportions;
+			this.instance.offset.click = inst.offset.click;
+
+			if(this.instance._intersectsWith(this.instance.containerCache)) {
+				innermostIntersecting = true;
+				$.each(inst.sortables, function () {
+					this.instance.positionAbs = inst.positionAbs;
+					this.instance.helperProportions = inst.helperProportions;
+					this.instance.offset.click = inst.offset.click;
+					if (this !== thisSortable &&
+						this.instance._intersectsWith(this.instance.containerCache) &&
+						$.contains(thisSortable.instance.element[0], this.instance.element[0])
+					) {
+						innermostIntersecting = false;
+					}
+					return innermostIntersecting;
+				});
+			}
+
+
+			if(innermostIntersecting) {
+				//If it intersects, we use a little isOver variable and set it once, so our move-in stuff gets fired only once
+				if(!this.instance.isOver) {
+
+					this.instance.isOver = 1;
+					//Now we fake the start of dragging for the sortable instance,
+					//by cloning the list group item, appending it to the sortable and using it as inst.currentItem
+					//We can then fire the start event of the sortable with our passed browser event, and our own helper (so it doesn't create a new one)
+					this.instance.currentItem = $(that).clone().removeAttr("id").appendTo(this.instance.element).data("ui-sortable-item", true);
+					this.instance.options._helper = this.instance.options.helper; //Store helper option to later restore it
+					this.instance.options.helper = function() { return ui.helper[0]; };
+
+					event.target = this.instance.currentItem[0];
+					this.instance._mouseCapture(event, true);
+					this.instance._mouseStart(event, true, true);
+
+					//Because the browser event is way off the new appended portlet, we modify a couple of variables to reflect the changes
+					this.instance.offset.click.top = inst.offset.click.top;
+					this.instance.offset.click.left = inst.offset.click.left;
+					this.instance.offset.parent.left -= inst.offset.parent.left - this.instance.offset.parent.left;
+					this.instance.offset.parent.top -= inst.offset.parent.top - this.instance.offset.parent.top;
+
+					inst._trigger("toSortable", event);
+					inst.dropped = this.instance.element; //draggable revert needs that
+					//hack so receive/update callbacks work (mostly)
+					inst.currentItem = inst.element;
+					this.instance.fromOutside = inst;
+
+				}
+
+				//Provided we did all the previous steps, we can fire the drag event of the sortable on every draggable drag, when it intersects with the sortable
+				if(this.instance.currentItem) {
+					this.instance._mouseDrag(event);
+				}
+
+			} else {
+
+				//If it doesn't intersect with the sortable, and it intersected before,
+				//we fake the drag stop of the sortable, but make sure it doesn't remove the helper by using cancelHelperRemoval
+				if(this.instance.isOver) {
+
+					this.instance.isOver = 0;
+					this.instance.cancelHelperRemoval = true;
+
+					//Prevent reverting on this forced stop
+					this.instance.options.revert = false;
+
+					// The out event needs to be triggered independently
+					this.instance._trigger("out", event, this.instance._uiHash(this.instance));
+
+					this.instance._mouseStop(event, true);
+					this.instance.options.helper = this.instance.options._helper;
+
+					//Now we remove our currentItem, the list group clone again, and the placeholder, and animate the helper back to it's original size
+					this.instance.currentItem.remove();
+					if(this.instance.placeholder) {
+						this.instance.placeholder.remove();
+					}
+
+					inst._trigger("fromSortable", event);
+					inst.dropped = false; //draggable revert needs that
+				}
+
+			}
+
+		});
+
+	}
+});
+
+$.ui.plugin.add("draggable", "cursor", {
+	start: function() {
+		var t = $("body"), o = $(this).data("ui-draggable").options;
+		if (t.css("cursor")) {
+			o._cursor = t.css("cursor");
+		}
+		t.css("cursor", o.cursor);
+	},
+	stop: function() {
+		var o = $(this).data("ui-draggable").options;
+		if (o._cursor) {
+			$("body").css("cursor", o._cursor);
+		}
+	}
+});
+
+$.ui.plugin.add("draggable", "opacity", {
+	start: function(event, ui) {
+		var t = $(ui.helper), o = $(this).data("ui-draggable").options;
+		if(t.css("opacity")) {
+			o._opacity = t.css("opacity");
+		}
+		t.css("opacity", o.opacity);
+	},
+	stop: function(event, ui) {
+		var o = $(this).data("ui-draggable").options;
+		if(o._opacity) {
+			$(ui.helper).css("opacity", o._opacity);
+		}
+	}
+});
+
+$.ui.plugin.add("draggable", "scroll", {
+	start: function() {
+		var i = $(this).data("ui-draggable");
+		if(i.scrollParent[0] !== document && i.scrollParent[0].tagName !== "HTML") {
+			i.overflowOffset = i.scrollParent.offset();
+		}
+	},
+	drag: function( event ) {
+
+		var i = $(this).data("ui-draggable"), o = i.options, scrolled = false;
+
+		if(i.scrollParent[0] !== document && i.scrollParent[0].tagName !== "HTML") {
+
+			if(!o.axis || o.axis !== "x") {
+				if((i.overflowOffset.top + i.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity) {
+					i.scrollParent[0].scrollTop = scrolled = i.scrollParent[0].scrollTop + o.scrollSpeed;
+				} else if(event.pageY - i.overflowOffset.top < o.scrollSensitivity) {
+					i.scrollParent[0].scrollTop = scrolled = i.scrollParent[0].scrollTop - o.scrollSpeed;
+				}
+			}
+
+			if(!o.axis || o.axis !== "y") {
+				if((i.overflowOffset.left + i.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity) {
+					i.scrollParent[0].scrollLeft = scrolled = i.scrollParent[0].scrollLeft + o.scrollSpeed;
+				} else if(event.pageX - i.overflowOffset.left < o.scrollSensitivity) {
+					i.scrollParent[0].scrollLeft = scrolled = i.scrollParent[0].scrollLeft - o.scrollSpeed;
+				}
+			}
+
+		} else {
+
+			if(!o.axis || o.axis !== "x") {
+				if(event.pageY - $(document).scrollTop() < o.scrollSensitivity) {
+					scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
+				} else if($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity) {
+					scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
+				}
+			}
+
+			if(!o.axis || o.axis !== "y") {
+				if(event.pageX - $(document).scrollLeft() < o.scrollSensitivity) {
+					scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
+				} else if($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity) {
+					scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
+				}
+			}
+
+		}
+
+		if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) {
+			$.ui.ddmanager.prepareOffsets(i, event);
+		}
+
+	}
+});
+
+$.ui.plugin.add("draggable", "snap", {
+	start: function() {
+
+		var i = $(this).data("ui-draggable"),
+			o = i.options;
+
+		i.snapElements = [];
+
+		$(o.snap.constructor !== String ? ( o.snap.items || ":data(ui-draggable)" ) : o.snap).each(function() {
+			var $t = $(this),
+				$o = $t.offset();
+			if(this !== i.element[0]) {
+				i.snapElements.push({
+					item: this,
+					width: $t.outerWidth(), height: $t.outerHeight(),
+					top: $o.top, left: $o.left
+				});
+			}
+		});
+
+	},
+	drag: function(event, ui) {
+
+		var ts, bs, ls, rs, l, r, t, b, i, first,
+			inst = $(this).data("ui-draggable"),
+			o = inst.options,
+			d = o.snapTolerance,
+			x1 = ui.offset.left, x2 = x1 + inst.helperProportions.width,
+			y1 = ui.offset.top, y2 = y1 + inst.helperProportions.height;
+
+		for (i = inst.snapElements.length - 1; i >= 0; i--){
+
+			l = inst.snapElements[i].left;
+			r = l + inst.snapElements[i].width;
+			t = inst.snapElements[i].top;
+			b = t + inst.snapElements[i].height;
+
+			//Yes, I know, this is insane ;)
+			if(!((l-d < x1 && x1 < r+d && t-d < y1 && y1 < b+d) || (l-d < x1 && x1 < r+d && t-d < y2 && y2 < b+d) || (l-d < x2 && x2 < r+d && t-d < y1 && y1 < b+d) || (l-d < x2 && x2 < r+d && t-d < y2 && y2 < b+d))) {
+				if(inst.snapElements[i].snapping) {
+					(inst.options.snap.release && inst.options.snap.release.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
+				}
+				inst.snapElements[i].snapping = false;
+				continue;
+			}
+
+			if(o.snapMode !== "inner") {
+				ts = Math.abs(t - y2) <= d;
+				bs = Math.abs(b - y1) <= d;
+				ls = Math.abs(l - x2) <= d;
+				rs = Math.abs(r - x1) <= d;
+				if(ts) {
+					ui.position.top = inst._convertPositionTo("relative", { top: t - inst.helperProportions.height, left: 0 }).top - inst.margins.top;
+				}
+				if(bs) {
+					ui.position.top = inst._convertPositionTo("relative", { top: b, left: 0 }).top - inst.margins.top;
+				}
+				if(ls) {
+					ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l - inst.helperProportions.width }).left - inst.margins.left;
+				}
+				if(rs) {
+					ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r }).left - inst.margins.left;
+				}
+			}
+
+			first = (ts || bs || ls || rs);
+
+			if(o.snapMode !== "outer") {
+				ts = Math.abs(t - y1) <= d;
+				bs = Math.abs(b - y2) <= d;
+				ls = Math.abs(l - x1) <= d;
+				rs = Math.abs(r - x2) <= d;
+				if(ts) {
+					ui.position.top = inst._convertPositionTo("relative", { top: t, left: 0 }).top - inst.margins.top;
+				}
+				if(bs) {
+					ui.position.top = inst._convertPositionTo("relative", { top: b - inst.helperProportions.height, left: 0 }).top - inst.margins.top;
+				}
+				if(ls) {
+					ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l }).left - inst.margins.left;
+				}
+				if(rs) {
+					ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r - inst.helperProportions.width }).left - inst.margins.left;
+				}
+			}
+
+			if(!inst.snapElements[i].snapping && (ts || bs || ls || rs || first)) {
+				(inst.options.snap.snap && inst.options.snap.snap.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
+			}
+			inst.snapElements[i].snapping = (ts || bs || ls || rs || first);
+
+		}
+
+	}
+});
+
+$.ui.plugin.add("draggable", "stack", {
+	start: function() {
+		var min,
+			o = this.data("ui-draggable").options,
+			group = $.makeArray($(o.stack)).sort(function(a,b) {
+				return (parseInt($(a).css("zIndex"),10) || 0) - (parseInt($(b).css("zIndex"),10) || 0);
+			});
+
+		if (!group.length) { return; }
+
+		min = parseInt($(group[0]).css("zIndex"), 10) || 0;
+		$(group).each(function(i) {
+			$(this).css("zIndex", min + i);
+		});
+		this.css("zIndex", (min + group.length));
+	}
+});
+
+$.ui.plugin.add("draggable", "zIndex", {
+	start: function(event, ui) {
+		var t = $(ui.helper), o = $(this).data("ui-draggable").options;
+		if(t.css("zIndex")) {
+			o._zIndex = t.css("zIndex");
+		}
+		t.css("zIndex", o.zIndex);
+	},
+	stop: function(event, ui) {
+		var o = $(this).data("ui-draggable").options;
+		if(o._zIndex) {
+			$(ui.helper).css("zIndex", o._zIndex);
+		}
+	}
+});
+
+})(jQuery);
+
+});
\ No newline at end of file
diff --git a/module/web/static/js/libs/jqueryui/droppable.js b/module/web/static/js/libs/jqueryui/droppable.js
new file mode 100644
index 000000000..24b9731be
--- /dev/null
+++ b/module/web/static/js/libs/jqueryui/droppable.js
@@ -0,0 +1,374 @@
+define(['jquery','./core','./widget','./mouse','./draggable'], function (jQuery) {
+/*!
+ * jQuery UI Droppable 1.10.1
+ * http://jqueryui.com
+ *
+ * Copyright 2013 jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ *
+ * http://api.jqueryui.com/droppable/
+ *
+ * Depends:
+ *	jquery.ui.core.js
+ *	jquery.ui.widget.js
+ *	jquery.ui.mouse.js
+ *	jquery.ui.draggable.js
+ */
+(function( $, undefined ) {
+
+function isOverAxis( x, reference, size ) {
+	return ( x > reference ) && ( x < ( reference + size ) );
+}
+
+$.widget("ui.droppable", {
+	version: "1.10.1",
+	widgetEventPrefix: "drop",
+	options: {
+		accept: "*",
+		activeClass: false,
+		addClasses: true,
+		greedy: false,
+		hoverClass: false,
+		scope: "default",
+		tolerance: "intersect",
+
+		// callbacks
+		activate: null,
+		deactivate: null,
+		drop: null,
+		out: null,
+		over: null
+	},
+	_create: function() {
+
+		var o = this.options,
+			accept = o.accept;
+
+		this.isover = false;
+		this.isout = true;
+
+		this.accept = $.isFunction(accept) ? accept : function(d) {
+			return d.is(accept);
+		};
+
+		//Store the droppable's proportions
+		this.proportions = { width: this.element[0].offsetWidth, height: this.element[0].offsetHeight };
+
+		// Add the reference and positions to the manager
+		$.ui.ddmanager.droppables[o.scope] = $.ui.ddmanager.droppables[o.scope] || [];
+		$.ui.ddmanager.droppables[o.scope].push(this);
+
+		(o.addClasses && this.element.addClass("ui-droppable"));
+
+	},
+
+	_destroy: function() {
+		var i = 0,
+			drop = $.ui.ddmanager.droppables[this.options.scope];
+
+		for ( ; i < drop.length; i++ ) {
+			if ( drop[i] === this ) {
+				drop.splice(i, 1);
+			}
+		}
+
+		this.element.removeClass("ui-droppable ui-droppable-disabled");
+	},
+
+	_setOption: function(key, value) {
+
+		if(key === "accept") {
+			this.accept = $.isFunction(value) ? value : function(d) {
+				return d.is(value);
+			};
+		}
+		$.Widget.prototype._setOption.apply(this, arguments);
+	},
+
+	_activate: function(event) {
+		var draggable = $.ui.ddmanager.current;
+		if(this.options.activeClass) {
+			this.element.addClass(this.options.activeClass);
+		}
+		if(draggable){
+			this._trigger("activate", event, this.ui(draggable));
+		}
+	},
+
+	_deactivate: function(event) {
+		var draggable = $.ui.ddmanager.current;
+		if(this.options.activeClass) {
+			this.element.removeClass(this.options.activeClass);
+		}
+		if(draggable){
+			this._trigger("deactivate", event, this.ui(draggable));
+		}
+	},
+
+	_over: function(event) {
+
+		var draggable = $.ui.ddmanager.current;
+
+		// Bail if draggable and droppable are same element
+		if (!draggable || (draggable.currentItem || draggable.element)[0] === this.element[0]) {
+			return;
+		}
+
+		if (this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
+			if(this.options.hoverClass) {
+				this.element.addClass(this.options.hoverClass);
+			}
+			this._trigger("over", event, this.ui(draggable));
+		}
+
+	},
+
+	_out: function(event) {
+
+		var draggable = $.ui.ddmanager.current;
+
+		// Bail if draggable and droppable are same element
+		if (!draggable || (draggable.currentItem || draggable.element)[0] === this.element[0]) {
+			return;
+		}
+
+		if (this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
+			if(this.options.hoverClass) {
+				this.element.removeClass(this.options.hoverClass);
+			}
+			this._trigger("out", event, this.ui(draggable));
+		}
+
+	},
+
+	_drop: function(event,custom) {
+
+		var draggable = custom || $.ui.ddmanager.current,
+			childrenIntersection = false;
+
+		// Bail if draggable and droppable are same element
+		if (!draggable || (draggable.currentItem || draggable.element)[0] === this.element[0]) {
+			return false;
+		}
+
+		this.element.find(":data(ui-droppable)").not(".ui-draggable-dragging").each(function() {
+			var inst = $.data(this, "ui-droppable");
+			if(
+				inst.options.greedy &&
+				!inst.options.disabled &&
+				inst.options.scope === draggable.options.scope &&
+				inst.accept.call(inst.element[0], (draggable.currentItem || draggable.element)) &&
+				$.ui.intersect(draggable, $.extend(inst, { offset: inst.element.offset() }), inst.options.tolerance)
+			) { childrenIntersection = true; return false; }
+		});
+		if(childrenIntersection) {
+			return false;
+		}
+
+		if(this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
+			if(this.options.activeClass) {
+				this.element.removeClass(this.options.activeClass);
+			}
+			if(this.options.hoverClass) {
+				this.element.removeClass(this.options.hoverClass);
+			}
+			this._trigger("drop", event, this.ui(draggable));
+			return this.element;
+		}
+
+		return false;
+
+	},
+
+	ui: function(c) {
+		return {
+			draggable: (c.currentItem || c.element),
+			helper: c.helper,
+			position: c.position,
+			offset: c.positionAbs
+		};
+	}
+
+});
+
+$.ui.intersect = function(draggable, droppable, toleranceMode) {
+
+	if (!droppable.offset) {
+		return false;
+	}
+
+	var draggableLeft, draggableTop,
+		x1 = (draggable.positionAbs || draggable.position.absolute).left, x2 = x1 + draggable.helperProportions.width,
+		y1 = (draggable.positionAbs || draggable.position.absolute).top, y2 = y1 + draggable.helperProportions.height,
+		l = droppable.offset.left, r = l + droppable.proportions.width,
+		t = droppable.offset.top, b = t + droppable.proportions.height;
+
+	switch (toleranceMode) {
+		case "fit":
+			return (l <= x1 && x2 <= r && t <= y1 && y2 <= b);
+		case "intersect":
+			return (l < x1 + (draggable.helperProportions.width / 2) && // Right Half
+				x2 - (draggable.helperProportions.width / 2) < r && // Left Half
+				t < y1 + (draggable.helperProportions.height / 2) && // Bottom Half
+				y2 - (draggable.helperProportions.height / 2) < b ); // Top Half
+		case "pointer":
+			draggableLeft = ((draggable.positionAbs || draggable.position.absolute).left + (draggable.clickOffset || draggable.offset.click).left);
+			draggableTop = ((draggable.positionAbs || draggable.position.absolute).top + (draggable.clickOffset || draggable.offset.click).top);
+			return isOverAxis( draggableTop, t, droppable.proportions.height ) && isOverAxis( draggableLeft, l, droppable.proportions.width );
+		case "touch":
+			return (
+				(y1 >= t && y1 <= b) ||	// Top edge touching
+				(y2 >= t && y2 <= b) ||	// Bottom edge touching
+				(y1 < t && y2 > b)		// Surrounded vertically
+			) && (
+				(x1 >= l && x1 <= r) ||	// Left edge touching
+				(x2 >= l && x2 <= r) ||	// Right edge touching
+				(x1 < l && x2 > r)		// Surrounded horizontally
+			);
+		default:
+			return false;
+		}
+
+};
+
+/*
+	This manager tracks offsets of draggables and droppables
+*/
+$.ui.ddmanager = {
+	current: null,
+	droppables: { "default": [] },
+	prepareOffsets: function(t, event) {
+
+		var i, j,
+			m = $.ui.ddmanager.droppables[t.options.scope] || [],
+			type = event ? event.type : null, // workaround for #2317
+			list = (t.currentItem || t.element).find(":data(ui-droppable)").addBack();
+
+		droppablesLoop: for (i = 0; i < m.length; i++) {
+
+			//No disabled and non-accepted
+			if(m[i].options.disabled || (t && !m[i].accept.call(m[i].element[0],(t.currentItem || t.element)))) {
+				continue;
+			}
+
+			// Filter out elements in the current dragged item
+			for (j=0; j < list.length; j++) {
+				if(list[j] === m[i].element[0]) {
+					m[i].proportions.height = 0;
+					continue droppablesLoop;
+				}
+			}
+
+			m[i].visible = m[i].element.css("display") !== "none";
+			if(!m[i].visible) {
+				continue;
+			}
+
+			//Activate the droppable if used directly from draggables
+			if(type === "mousedown") {
+				m[i]._activate.call(m[i], event);
+			}
+
+			m[i].offset = m[i].element.offset();
+			m[i].proportions = { width: m[i].element[0].offsetWidth, height: m[i].element[0].offsetHeight };
+
+		}
+
+	},
+	drop: function(draggable, event) {
+
+		var dropped = false;
+		$.each($.ui.ddmanager.droppables[draggable.options.scope] || [], function() {
+
+			if(!this.options) {
+				return;
+			}
+			if (!this.options.disabled && this.visible && $.ui.intersect(draggable, this, this.options.tolerance)) {
+				dropped = this._drop.call(this, event) || dropped;
+			}
+
+			if (!this.options.disabled && this.visible && this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
+				this.isout = true;
+				this.isover = false;
+				this._deactivate.call(this, event);
+			}
+
+		});
+		return dropped;
+
+	},
+	dragStart: function( draggable, event ) {
+		//Listen for scrolling so that if the dragging causes scrolling the position of the droppables can be recalculated (see #5003)
+		draggable.element.parentsUntil( "body" ).bind( "scroll.droppable", function() {
+			if( !draggable.options.refreshPositions ) {
+				$.ui.ddmanager.prepareOffsets( draggable, event );
+			}
+		});
+	},
+	drag: function(draggable, event) {
+
+		//If you have a highly dynamic page, you might try this option. It renders positions every time you move the mouse.
+		if(draggable.options.refreshPositions) {
+			$.ui.ddmanager.prepareOffsets(draggable, event);
+		}
+
+		//Run through all droppables and check their positions based on specific tolerance options
+		$.each($.ui.ddmanager.droppables[draggable.options.scope] || [], function() {
+
+			if(this.options.disabled || this.greedyChild || !this.visible) {
+				return;
+			}
+
+			var parentInstance, scope, parent,
+				intersects = $.ui.intersect(draggable, this, this.options.tolerance),
+				c = !intersects && this.isover ? "isout" : (intersects && !this.isover ? "isover" : null);
+			if(!c) {
+				return;
+			}
+
+			if (this.options.greedy) {
+				// find droppable parents with same scope
+				scope = this.options.scope;
+				parent = this.element.parents(":data(ui-droppable)").filter(function () {
+					return $.data(this, "ui-droppable").options.scope === scope;
+				});
+
+				if (parent.length) {
+					parentInstance = $.data(parent[0], "ui-droppable");
+					parentInstance.greedyChild = (c === "isover");
+				}
+			}
+
+			// we just moved into a greedy child
+			if (parentInstance && c === "isover") {
+				parentInstance.isover = false;
+				parentInstance.isout = true;
+				parentInstance._out.call(parentInstance, event);
+			}
+
+			this[c] = true;
+			this[c === "isout" ? "isover" : "isout"] = false;
+			this[c === "isover" ? "_over" : "_out"].call(this, event);
+
+			// we just moved out of a greedy child
+			if (parentInstance && c === "isout") {
+				parentInstance.isout = false;
+				parentInstance.isover = true;
+				parentInstance._over.call(parentInstance, event);
+			}
+		});
+
+	},
+	dragStop: function( draggable, event ) {
+		draggable.element.parentsUntil( "body" ).unbind( "scroll.droppable" );
+		//Call prepareOffsets one final time since IE does not fire return scroll events when overflow was caused by drag (see #5003)
+		if( !draggable.options.refreshPositions ) {
+			$.ui.ddmanager.prepareOffsets( draggable, event );
+		}
+	}
+};
+
+})(jQuery);
+
+});
\ No newline at end of file
diff --git a/module/web/static/js/libs/jqueryui/mouse.js b/module/web/static/js/libs/jqueryui/mouse.js
new file mode 100644
index 000000000..4f9fb7178
--- /dev/null
+++ b/module/web/static/js/libs/jqueryui/mouse.js
@@ -0,0 +1,172 @@
+define(['jquery','./widget'], function (jQuery) {
+/*!
+ * jQuery UI Mouse 1.10.1
+ * http://jqueryui.com
+ *
+ * Copyright 2013 jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ *
+ * http://api.jqueryui.com/mouse/
+ *
+ * Depends:
+ *	jquery.ui.widget.js
+ */
+(function( $, undefined ) {
+
+var mouseHandled = false;
+$( document ).mouseup( function() {
+	mouseHandled = false;
+});
+
+$.widget("ui.mouse", {
+	version: "1.10.1",
+	options: {
+		cancel: "input,textarea,button,select,option",
+		distance: 1,
+		delay: 0
+	},
+	_mouseInit: function() {
+		var that = this;
+
+		this.element
+			.bind("mousedown."+this.widgetName, function(event) {
+				return that._mouseDown(event);
+			})
+			.bind("click."+this.widgetName, function(event) {
+				if (true === $.data(event.target, that.widgetName + ".preventClickEvent")) {
+					$.removeData(event.target, that.widgetName + ".preventClickEvent");
+					event.stopImmediatePropagation();
+					return false;
+				}
+			});
+
+		this.started = false;
+	},
+
+	// TODO: make sure destroying one instance of mouse doesn't mess with
+	// other instances of mouse
+	_mouseDestroy: function() {
+		this.element.unbind("."+this.widgetName);
+		if ( this._mouseMoveDelegate ) {
+			$(document)
+				.unbind("mousemove."+this.widgetName, this._mouseMoveDelegate)
+				.unbind("mouseup."+this.widgetName, this._mouseUpDelegate);
+		}
+	},
+
+	_mouseDown: function(event) {
+		// don't let more than one widget handle mouseStart
+		if( mouseHandled ) { return; }
+
+		// we may have missed mouseup (out of window)
+		(this._mouseStarted && this._mouseUp(event));
+
+		this._mouseDownEvent = event;
+
+		var that = this,
+			btnIsLeft = (event.which === 1),
+			// event.target.nodeName works around a bug in IE 8 with
+			// disabled inputs (#7620)
+			elIsCancel = (typeof this.options.cancel === "string" && event.target.nodeName ? $(event.target).closest(this.options.cancel).length : false);
+		if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {
+			return true;
+		}
+
+		this.mouseDelayMet = !this.options.delay;
+		if (!this.mouseDelayMet) {
+			this._mouseDelayTimer = setTimeout(function() {
+				that.mouseDelayMet = true;
+			}, this.options.delay);
+		}
+
+		if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
+			this._mouseStarted = (this._mouseStart(event) !== false);
+			if (!this._mouseStarted) {
+				event.preventDefault();
+				return true;
+			}
+		}
+
+		// Click event may never have fired (Gecko & Opera)
+		if (true === $.data(event.target, this.widgetName + ".preventClickEvent")) {
+			$.removeData(event.target, this.widgetName + ".preventClickEvent");
+		}
+
+		// these delegates are required to keep context
+		this._mouseMoveDelegate = function(event) {
+			return that._mouseMove(event);
+		};
+		this._mouseUpDelegate = function(event) {
+			return that._mouseUp(event);
+		};
+		$(document)
+			.bind("mousemove."+this.widgetName, this._mouseMoveDelegate)
+			.bind("mouseup."+this.widgetName, this._mouseUpDelegate);
+
+		event.preventDefault();
+
+		mouseHandled = true;
+		return true;
+	},
+
+	_mouseMove: function(event) {
+		// IE mouseup check - mouseup happened when mouse was out of window
+		if ($.ui.ie && ( !document.documentMode || document.documentMode < 9 ) && !event.button) {
+			return this._mouseUp(event);
+		}
+
+		if (this._mouseStarted) {
+			this._mouseDrag(event);
+			return event.preventDefault();
+		}
+
+		if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
+			this._mouseStarted =
+				(this._mouseStart(this._mouseDownEvent, event) !== false);
+			(this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event));
+		}
+
+		return !this._mouseStarted;
+	},
+
+	_mouseUp: function(event) {
+		$(document)
+			.unbind("mousemove."+this.widgetName, this._mouseMoveDelegate)
+			.unbind("mouseup."+this.widgetName, this._mouseUpDelegate);
+
+		if (this._mouseStarted) {
+			this._mouseStarted = false;
+
+			if (event.target === this._mouseDownEvent.target) {
+				$.data(event.target, this.widgetName + ".preventClickEvent", true);
+			}
+
+			this._mouseStop(event);
+		}
+
+		return false;
+	},
+
+	_mouseDistanceMet: function(event) {
+		return (Math.max(
+				Math.abs(this._mouseDownEvent.pageX - event.pageX),
+				Math.abs(this._mouseDownEvent.pageY - event.pageY)
+			) >= this.options.distance
+		);
+	},
+
+	_mouseDelayMet: function(/* event */) {
+		return this.mouseDelayMet;
+	},
+
+	// These are placeholder methods, to be overriden by extending plugin
+	_mouseStart: function(/* event */) {},
+	_mouseDrag: function(/* event */) {},
+	_mouseStop: function(/* event */) {},
+	_mouseCapture: function(/* event */) { return true; }
+});
+
+})(jQuery);
+
+});
\ No newline at end of file
diff --git a/module/web/static/js/libs/jqueryui/position.js b/module/web/static/js/libs/jqueryui/position.js
new file mode 100644
index 000000000..38bbfa38c
--- /dev/null
+++ b/module/web/static/js/libs/jqueryui/position.js
@@ -0,0 +1,500 @@
+define(['jquery'], function (jQuery) {
+/*!
+ * jQuery UI Position 1.10.1
+ * http://jqueryui.com
+ *
+ * Copyright 2013 jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ *
+ * http://api.jqueryui.com/position/
+ */
+(function( $, undefined ) {
+
+$.ui = $.ui || {};
+
+var cachedScrollbarWidth,
+	max = Math.max,
+	abs = Math.abs,
+	round = Math.round,
+	rhorizontal = /left|center|right/,
+	rvertical = /top|center|bottom/,
+	roffset = /[\+\-]\d+(\.[\d]+)?%?/,
+	rposition = /^\w+/,
+	rpercent = /%$/,
+	_position = $.fn.position;
+
+function getOffsets( offsets, width, height ) {
+	return [
+		parseFloat( offsets[ 0 ] ) * ( rpercent.test( offsets[ 0 ] ) ? width / 100 : 1 ),
+		parseFloat( offsets[ 1 ] ) * ( rpercent.test( offsets[ 1 ] ) ? height / 100 : 1 )
+	];
+}
+
+function parseCss( element, property ) {
+	return parseInt( $.css( element, property ), 10 ) || 0;
+}
+
+function getDimensions( elem ) {
+	var raw = elem[0];
+	if ( raw.nodeType === 9 ) {
+		return {
+			width: elem.width(),
+			height: elem.height(),
+			offset: { top: 0, left: 0 }
+		};
+	}
+	if ( $.isWindow( raw ) ) {
+		return {
+			width: elem.width(),
+			height: elem.height(),
+			offset: { top: elem.scrollTop(), left: elem.scrollLeft() }
+		};
+	}
+	if ( raw.preventDefault ) {
+		return {
+			width: 0,
+			height: 0,
+			offset: { top: raw.pageY, left: raw.pageX }
+		};
+	}
+	return {
+		width: elem.outerWidth(),
+		height: elem.outerHeight(),
+		offset: elem.offset()
+	};
+}
+
+$.position = {
+	scrollbarWidth: function() {
+		if ( cachedScrollbarWidth !== undefined ) {
+			return cachedScrollbarWidth;
+		}
+		var w1, w2,
+			div = $( "<div style='display:block;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>" ),
+			innerDiv = div.children()[0];
+
+		$( "body" ).append( div );
+		w1 = innerDiv.offsetWidth;
+		div.css( "overflow", "scroll" );
+
+		w2 = innerDiv.offsetWidth;
+
+		if ( w1 === w2 ) {
+			w2 = div[0].clientWidth;
+		}
+
+		div.remove();
+
+		return (cachedScrollbarWidth = w1 - w2);
+	},
+	getScrollInfo: function( within ) {
+		var overflowX = within.isWindow ? "" : within.element.css( "overflow-x" ),
+			overflowY = within.isWindow ? "" : within.element.css( "overflow-y" ),
+			hasOverflowX = overflowX === "scroll" ||
+				( overflowX === "auto" && within.width < within.element[0].scrollWidth ),
+			hasOverflowY = overflowY === "scroll" ||
+				( overflowY === "auto" && within.height < within.element[0].scrollHeight );
+		return {
+			width: hasOverflowX ? $.position.scrollbarWidth() : 0,
+			height: hasOverflowY ? $.position.scrollbarWidth() : 0
+		};
+	},
+	getWithinInfo: function( element ) {
+		var withinElement = $( element || window ),
+			isWindow = $.isWindow( withinElement[0] );
+		return {
+			element: withinElement,
+			isWindow: isWindow,
+			offset: withinElement.offset() || { left: 0, top: 0 },
+			scrollLeft: withinElement.scrollLeft(),
+			scrollTop: withinElement.scrollTop(),
+			width: isWindow ? withinElement.width() : withinElement.outerWidth(),
+			height: isWindow ? withinElement.height() : withinElement.outerHeight()
+		};
+	}
+};
+
+$.fn.position = function( options ) {
+	if ( !options || !options.of ) {
+		return _position.apply( this, arguments );
+	}
+
+	// make a copy, we don't want to modify arguments
+	options = $.extend( {}, options );
+
+	var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions,
+		target = $( options.of ),
+		within = $.position.getWithinInfo( options.within ),
+		scrollInfo = $.position.getScrollInfo( within ),
+		collision = ( options.collision || "flip" ).split( " " ),
+		offsets = {};
+
+	dimensions = getDimensions( target );
+	if ( target[0].preventDefault ) {
+		// force left top to allow flipping
+		options.at = "left top";
+	}
+	targetWidth = dimensions.width;
+	targetHeight = dimensions.height;
+	targetOffset = dimensions.offset;
+	// clone to reuse original targetOffset later
+	basePosition = $.extend( {}, targetOffset );
+
+	// force my and at to have valid horizontal and vertical positions
+	// if a value is missing or invalid, it will be converted to center
+	$.each( [ "my", "at" ], function() {
+		var pos = ( options[ this ] || "" ).split( " " ),
+			horizontalOffset,
+			verticalOffset;
+
+		if ( pos.length === 1) {
+			pos = rhorizontal.test( pos[ 0 ] ) ?
+				pos.concat( [ "center" ] ) :
+				rvertical.test( pos[ 0 ] ) ?
+					[ "center" ].concat( pos ) :
+					[ "center", "center" ];
+		}
+		pos[ 0 ] = rhorizontal.test( pos[ 0 ] ) ? pos[ 0 ] : "center";
+		pos[ 1 ] = rvertical.test( pos[ 1 ] ) ? pos[ 1 ] : "center";
+
+		// calculate offsets
+		horizontalOffset = roffset.exec( pos[ 0 ] );
+		verticalOffset = roffset.exec( pos[ 1 ] );
+		offsets[ this ] = [
+			horizontalOffset ? horizontalOffset[ 0 ] : 0,
+			verticalOffset ? verticalOffset[ 0 ] : 0
+		];
+
+		// reduce to just the positions without the offsets
+		options[ this ] = [
+			rposition.exec( pos[ 0 ] )[ 0 ],
+			rposition.exec( pos[ 1 ] )[ 0 ]
+		];
+	});
+
+	// normalize collision option
+	if ( collision.length === 1 ) {
+		collision[ 1 ] = collision[ 0 ];
+	}
+
+	if ( options.at[ 0 ] === "right" ) {
+		basePosition.left += targetWidth;
+	} else if ( options.at[ 0 ] === "center" ) {
+		basePosition.left += targetWidth / 2;
+	}
+
+	if ( options.at[ 1 ] === "bottom" ) {
+		basePosition.top += targetHeight;
+	} else if ( options.at[ 1 ] === "center" ) {
+		basePosition.top += targetHeight / 2;
+	}
+
+	atOffset = getOffsets( offsets.at, targetWidth, targetHeight );
+	basePosition.left += atOffset[ 0 ];
+	basePosition.top += atOffset[ 1 ];
+
+	return this.each(function() {
+		var collisionPosition, using,
+			elem = $( this ),
+			elemWidth = elem.outerWidth(),
+			elemHeight = elem.outerHeight(),
+			marginLeft = parseCss( this, "marginLeft" ),
+			marginTop = parseCss( this, "marginTop" ),
+			collisionWidth = elemWidth + marginLeft + parseCss( this, "marginRight" ) + scrollInfo.width,
+			collisionHeight = elemHeight + marginTop + parseCss( this, "marginBottom" ) + scrollInfo.height,
+			position = $.extend( {}, basePosition ),
+			myOffset = getOffsets( offsets.my, elem.outerWidth(), elem.outerHeight() );
+
+		if ( options.my[ 0 ] === "right" ) {
+			position.left -= elemWidth;
+		} else if ( options.my[ 0 ] === "center" ) {
+			position.left -= elemWidth / 2;
+		}
+
+		if ( options.my[ 1 ] === "bottom" ) {
+			position.top -= elemHeight;
+		} else if ( options.my[ 1 ] === "center" ) {
+			position.top -= elemHeight / 2;
+		}
+
+		position.left += myOffset[ 0 ];
+		position.top += myOffset[ 1 ];
+
+		// if the browser doesn't support fractions, then round for consistent results
+		if ( !$.support.offsetFractions ) {
+			position.left = round( position.left );
+			position.top = round( position.top );
+		}
+
+		collisionPosition = {
+			marginLeft: marginLeft,
+			marginTop: marginTop
+		};
+
+		$.each( [ "left", "top" ], function( i, dir ) {
+			if ( $.ui.position[ collision[ i ] ] ) {
+				$.ui.position[ collision[ i ] ][ dir ]( position, {
+					targetWidth: targetWidth,
+					targetHeight: targetHeight,
+					elemWidth: elemWidth,
+					elemHeight: elemHeight,
+					collisionPosition: collisionPosition,
+					collisionWidth: collisionWidth,
+					collisionHeight: collisionHeight,
+					offset: [ atOffset[ 0 ] + myOffset[ 0 ], atOffset [ 1 ] + myOffset[ 1 ] ],
+					my: options.my,
+					at: options.at,
+					within: within,
+					elem : elem
+				});
+			}
+		});
+
+		if ( options.using ) {
+			// adds feedback as second argument to using callback, if present
+			using = function( props ) {
+				var left = targetOffset.left - position.left,
+					right = left + targetWidth - elemWidth,
+					top = targetOffset.top - position.top,
+					bottom = top + targetHeight - elemHeight,
+					feedback = {
+						target: {
+							element: target,
+							left: targetOffset.left,
+							top: targetOffset.top,
+							width: targetWidth,
+							height: targetHeight
+						},
+						element: {
+							element: elem,
+							left: position.left,
+							top: position.top,
+							width: elemWidth,
+							height: elemHeight
+						},
+						horizontal: right < 0 ? "left" : left > 0 ? "right" : "center",
+						vertical: bottom < 0 ? "top" : top > 0 ? "bottom" : "middle"
+					};
+				if ( targetWidth < elemWidth && abs( left + right ) < targetWidth ) {
+					feedback.horizontal = "center";
+				}
+				if ( targetHeight < elemHeight && abs( top + bottom ) < targetHeight ) {
+					feedback.vertical = "middle";
+				}
+				if ( max( abs( left ), abs( right ) ) > max( abs( top ), abs( bottom ) ) ) {
+					feedback.important = "horizontal";
+				} else {
+					feedback.important = "vertical";
+				}
+				options.using.call( this, props, feedback );
+			};
+		}
+
+		elem.offset( $.extend( position, { using: using } ) );
+	});
+};
+
+$.ui.position = {
+	fit: {
+		left: function( position, data ) {
+			var within = data.within,
+				withinOffset = within.isWindow ? within.scrollLeft : within.offset.left,
+				outerWidth = within.width,
+				collisionPosLeft = position.left - data.collisionPosition.marginLeft,
+				overLeft = withinOffset - collisionPosLeft,
+				overRight = collisionPosLeft + data.collisionWidth - outerWidth - withinOffset,
+				newOverRight;
+
+			// element is wider than within
+			if ( data.collisionWidth > outerWidth ) {
+				// element is initially over the left side of within
+				if ( overLeft > 0 && overRight <= 0 ) {
+					newOverRight = position.left + overLeft + data.collisionWidth - outerWidth - withinOffset;
+					position.left += overLeft - newOverRight;
+				// element is initially over right side of within
+				} else if ( overRight > 0 && overLeft <= 0 ) {
+					position.left = withinOffset;
+				// element is initially over both left and right sides of within
+				} else {
+					if ( overLeft > overRight ) {
+						position.left = withinOffset + outerWidth - data.collisionWidth;
+					} else {
+						position.left = withinOffset;
+					}
+				}
+			// too far left -> align with left edge
+			} else if ( overLeft > 0 ) {
+				position.left += overLeft;
+			// too far right -> align with right edge
+			} else if ( overRight > 0 ) {
+				position.left -= overRight;
+			// adjust based on position and margin
+			} else {
+				position.left = max( position.left - collisionPosLeft, position.left );
+			}
+		},
+		top: function( position, data ) {
+			var within = data.within,
+				withinOffset = within.isWindow ? within.scrollTop : within.offset.top,
+				outerHeight = data.within.height,
+				collisionPosTop = position.top - data.collisionPosition.marginTop,
+				overTop = withinOffset - collisionPosTop,
+				overBottom = collisionPosTop + data.collisionHeight - outerHeight - withinOffset,
+				newOverBottom;
+
+			// element is taller than within
+			if ( data.collisionHeight > outerHeight ) {
+				// element is initially over the top of within
+				if ( overTop > 0 && overBottom <= 0 ) {
+					newOverBottom = position.top + overTop + data.collisionHeight - outerHeight - withinOffset;
+					position.top += overTop - newOverBottom;
+				// element is initially over bottom of within
+				} else if ( overBottom > 0 && overTop <= 0 ) {
+					position.top = withinOffset;
+				// element is initially over both top and bottom of within
+				} else {
+					if ( overTop > overBottom ) {
+						position.top = withinOffset + outerHeight - data.collisionHeight;
+					} else {
+						position.top = withinOffset;
+					}
+				}
+			// too far up -> align with top
+			} else if ( overTop > 0 ) {
+				position.top += overTop;
+			// too far down -> align with bottom edge
+			} else if ( overBottom > 0 ) {
+				position.top -= overBottom;
+			// adjust based on position and margin
+			} else {
+				position.top = max( position.top - collisionPosTop, position.top );
+			}
+		}
+	},
+	flip: {
+		left: function( position, data ) {
+			var within = data.within,
+				withinOffset = within.offset.left + within.scrollLeft,
+				outerWidth = within.width,
+				offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left,
+				collisionPosLeft = position.left - data.collisionPosition.marginLeft,
+				overLeft = collisionPosLeft - offsetLeft,
+				overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft,
+				myOffset = data.my[ 0 ] === "left" ?
+					-data.elemWidth :
+					data.my[ 0 ] === "right" ?
+						data.elemWidth :
+						0,
+				atOffset = data.at[ 0 ] === "left" ?
+					data.targetWidth :
+					data.at[ 0 ] === "right" ?
+						-data.targetWidth :
+						0,
+				offset = -2 * data.offset[ 0 ],
+				newOverRight,
+				newOverLeft;
+
+			if ( overLeft < 0 ) {
+				newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth - outerWidth - withinOffset;
+				if ( newOverRight < 0 || newOverRight < abs( overLeft ) ) {
+					position.left += myOffset + atOffset + offset;
+				}
+			}
+			else if ( overRight > 0 ) {
+				newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset + atOffset + offset - offsetLeft;
+				if ( newOverLeft > 0 || abs( newOverLeft ) < overRight ) {
+					position.left += myOffset + atOffset + offset;
+				}
+			}
+		},
+		top: function( position, data ) {
+			var within = data.within,
+				withinOffset = within.offset.top + within.scrollTop,
+				outerHeight = within.height,
+				offsetTop = within.isWindow ? within.scrollTop : within.offset.top,
+				collisionPosTop = position.top - data.collisionPosition.marginTop,
+				overTop = collisionPosTop - offsetTop,
+				overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop,
+				top = data.my[ 1 ] === "top",
+				myOffset = top ?
+					-data.elemHeight :
+					data.my[ 1 ] === "bottom" ?
+						data.elemHeight :
+						0,
+				atOffset = data.at[ 1 ] === "top" ?
+					data.targetHeight :
+					data.at[ 1 ] === "bottom" ?
+						-data.targetHeight :
+						0,
+				offset = -2 * data.offset[ 1 ],
+				newOverTop,
+				newOverBottom;
+			if ( overTop < 0 ) {
+				newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight - outerHeight - withinOffset;
+				if ( ( position.top + myOffset + atOffset + offset) > overTop && ( newOverBottom < 0 || newOverBottom < abs( overTop ) ) ) {
+					position.top += myOffset + atOffset + offset;
+				}
+			}
+			else if ( overBottom > 0 ) {
+				newOverTop = position.top -  data.collisionPosition.marginTop + myOffset + atOffset + offset - offsetTop;
+				if ( ( position.top + myOffset + atOffset + offset) > overBottom && ( newOverTop > 0 || abs( newOverTop ) < overBottom ) ) {
+					position.top += myOffset + atOffset + offset;
+				}
+			}
+		}
+	},
+	flipfit: {
+		left: function() {
+			$.ui.position.flip.left.apply( this, arguments );
+			$.ui.position.fit.left.apply( this, arguments );
+		},
+		top: function() {
+			$.ui.position.flip.top.apply( this, arguments );
+			$.ui.position.fit.top.apply( this, arguments );
+		}
+	}
+};
+
+// fraction support test
+(function () {
+	var testElement, testElementParent, testElementStyle, offsetLeft, i,
+		body = document.getElementsByTagName( "body" )[ 0 ],
+		div = document.createElement( "div" );
+
+	//Create a "fake body" for testing based on method used in jQuery.support
+	testElement = document.createElement( body ? "div" : "body" );
+	testElementStyle = {
+		visibility: "hidden",
+		width: 0,
+		height: 0,
+		border: 0,
+		margin: 0,
+		background: "none"
+	};
+	if ( body ) {
+		$.extend( testElementStyle, {
+			position: "absolute",
+			left: "-1000px",
+			top: "-1000px"
+		});
+	}
+	for ( i in testElementStyle ) {
+		testElement.style[ i ] = testElementStyle[ i ];
+	}
+	testElement.appendChild( div );
+	testElementParent = body || document.documentElement;
+	testElementParent.insertBefore( testElement, testElementParent.firstChild );
+
+	div.style.cssText = "position: absolute; left: 10.7432222px;";
+
+	offsetLeft = $( div ).offset().left;
+	$.support.offsetFractions = offsetLeft > 10 && offsetLeft < 11;
+
+	testElement.innerHTML = "";
+	testElementParent.removeChild( testElement );
+})();
+
+}( jQuery ) );
+
+});
\ No newline at end of file
diff --git a/module/web/static/js/libs/jqueryui/resizable.js b/module/web/static/js/libs/jqueryui/resizable.js
new file mode 100644
index 000000000..58c06cbf8
--- /dev/null
+++ b/module/web/static/js/libs/jqueryui/resizable.js
@@ -0,0 +1,971 @@
+define(['jquery','./core','./mouse','./widget'], function (jQuery) {
+/*!
+ * jQuery UI Resizable 1.10.1
+ * http://jqueryui.com
+ *
+ * Copyright 2013 jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ *
+ * http://api.jqueryui.com/resizable/
+ *
+ * Depends:
+ *	jquery.ui.core.js
+ *	jquery.ui.mouse.js
+ *	jquery.ui.widget.js
+ */
+(function( $, undefined ) {
+
+function num(v) {
+	return parseInt(v, 10) || 0;
+}
+
+function isNumber(value) {
+	return !isNaN(parseInt(value, 10));
+}
+
+$.widget("ui.resizable", $.ui.mouse, {
+	version: "1.10.1",
+	widgetEventPrefix: "resize",
+	options: {
+		alsoResize: false,
+		animate: false,
+		animateDuration: "slow",
+		animateEasing: "swing",
+		aspectRatio: false,
+		autoHide: false,
+		containment: false,
+		ghost: false,
+		grid: false,
+		handles: "e,s,se",
+		helper: false,
+		maxHeight: null,
+		maxWidth: null,
+		minHeight: 10,
+		minWidth: 10,
+		// See #7960
+		zIndex: 90,
+
+		// callbacks
+		resize: null,
+		start: null,
+		stop: null
+	},
+	_create: function() {
+
+		var n, i, handle, axis, hname,
+			that = this,
+			o = this.options;
+		this.element.addClass("ui-resizable");
+
+		$.extend(this, {
+			_aspectRatio: !!(o.aspectRatio),
+			aspectRatio: o.aspectRatio,
+			originalElement: this.element,
+			_proportionallyResizeElements: [],
+			_helper: o.helper || o.ghost || o.animate ? o.helper || "ui-resizable-helper" : null
+		});
+
+		//Wrap the element if it cannot hold child nodes
+		if(this.element[0].nodeName.match(/canvas|textarea|input|select|button|img/i)) {
+
+			//Create a wrapper element and set the wrapper to the new current internal element
+			this.element.wrap(
+				$("<div class='ui-wrapper' style='overflow: hidden;'></div>").css({
+					position: this.element.css("position"),
+					width: this.element.outerWidth(),
+					height: this.element.outerHeight(),
+					top: this.element.css("top"),
+					left: this.element.css("left")
+				})
+			);
+
+			//Overwrite the original this.element
+			this.element = this.element.parent().data(
+				"ui-resizable", this.element.data("ui-resizable")
+			);
+
+			this.elementIsWrapper = true;
+
+			//Move margins to the wrapper
+			this.element.css({ marginLeft: this.originalElement.css("marginLeft"), marginTop: this.originalElement.css("marginTop"), marginRight: this.originalElement.css("marginRight"), marginBottom: this.originalElement.css("marginBottom") });
+			this.originalElement.css({ marginLeft: 0, marginTop: 0, marginRight: 0, marginBottom: 0});
+
+			//Prevent Safari textarea resize
+			this.originalResizeStyle = this.originalElement.css("resize");
+			this.originalElement.css("resize", "none");
+
+			//Push the actual element to our proportionallyResize internal array
+			this._proportionallyResizeElements.push(this.originalElement.css({ position: "static", zoom: 1, display: "block" }));
+
+			// avoid IE jump (hard set the margin)
+			this.originalElement.css({ margin: this.originalElement.css("margin") });
+
+			// fix handlers offset
+			this._proportionallyResize();
+
+		}
+
+		this.handles = o.handles || (!$(".ui-resizable-handle", this.element).length ? "e,s,se" : { n: ".ui-resizable-n", e: ".ui-resizable-e", s: ".ui-resizable-s", w: ".ui-resizable-w", se: ".ui-resizable-se", sw: ".ui-resizable-sw", ne: ".ui-resizable-ne", nw: ".ui-resizable-nw" });
+		if(this.handles.constructor === String) {
+
+			if ( this.handles === "all") {
+				this.handles = "n,e,s,w,se,sw,ne,nw";
+			}
+
+			n = this.handles.split(",");
+			this.handles = {};
+
+			for(i = 0; i < n.length; i++) {
+
+				handle = $.trim(n[i]);
+				hname = "ui-resizable-"+handle;
+				axis = $("<div class='ui-resizable-handle " + hname + "'></div>");
+
+				// Apply zIndex to all handles - see #7960
+				axis.css({ zIndex: o.zIndex });
+
+				//TODO : What's going on here?
+				if ("se" === handle) {
+					axis.addClass("ui-icon ui-icon-gripsmall-diagonal-se");
+				}
+
+				//Insert into internal handles object and append to element
+				this.handles[handle] = ".ui-resizable-"+handle;
+				this.element.append(axis);
+			}
+
+		}
+
+		this._renderAxis = function(target) {
+
+			var i, axis, padPos, padWrapper;
+
+			target = target || this.element;
+
+			for(i in this.handles) {
+
+				if(this.handles[i].constructor === String) {
+					this.handles[i] = $(this.handles[i], this.element).show();
+				}
+
+				//Apply pad to wrapper element, needed to fix axis position (textarea, inputs, scrolls)
+				if (this.elementIsWrapper && this.originalElement[0].nodeName.match(/textarea|input|select|button/i)) {
+
+					axis = $(this.handles[i], this.element);
+
+					//Checking the correct pad and border
+					padWrapper = /sw|ne|nw|se|n|s/.test(i) ? axis.outerHeight() : axis.outerWidth();
+
+					//The padding type i have to apply...
+					padPos = [ "padding",
+						/ne|nw|n/.test(i) ? "Top" :
+						/se|sw|s/.test(i) ? "Bottom" :
+						/^e$/.test(i) ? "Right" : "Left" ].join("");
+
+					target.css(padPos, padWrapper);
+
+					this._proportionallyResize();
+
+				}
+
+				//TODO: What's that good for? There's not anything to be executed left
+				if(!$(this.handles[i]).length) {
+					continue;
+				}
+			}
+		};
+
+		//TODO: make renderAxis a prototype function
+		this._renderAxis(this.element);
+
+		this._handles = $(".ui-resizable-handle", this.element)
+			.disableSelection();
+
+		//Matching axis name
+		this._handles.mouseover(function() {
+			if (!that.resizing) {
+				if (this.className) {
+					axis = this.className.match(/ui-resizable-(se|sw|ne|nw|n|e|s|w)/i);
+				}
+				//Axis, default = se
+				that.axis = axis && axis[1] ? axis[1] : "se";
+			}
+		});
+
+		//If we want to auto hide the elements
+		if (o.autoHide) {
+			this._handles.hide();
+			$(this.element)
+				.addClass("ui-resizable-autohide")
+				.mouseenter(function() {
+					if (o.disabled) {
+						return;
+					}
+					$(this).removeClass("ui-resizable-autohide");
+					that._handles.show();
+				})
+				.mouseleave(function(){
+					if (o.disabled) {
+						return;
+					}
+					if (!that.resizing) {
+						$(this).addClass("ui-resizable-autohide");
+						that._handles.hide();
+					}
+				});
+		}
+
+		//Initialize the mouse interaction
+		this._mouseInit();
+
+	},
+
+	_destroy: function() {
+
+		this._mouseDestroy();
+
+		var wrapper,
+			_destroy = function(exp) {
+				$(exp).removeClass("ui-resizable ui-resizable-disabled ui-resizable-resizing")
+					.removeData("resizable").removeData("ui-resizable").unbind(".resizable").find(".ui-resizable-handle").remove();
+			};
+
+		//TODO: Unwrap at same DOM position
+		if (this.elementIsWrapper) {
+			_destroy(this.element);
+			wrapper = this.element;
+			this.originalElement.css({
+				position: wrapper.css("position"),
+				width: wrapper.outerWidth(),
+				height: wrapper.outerHeight(),
+				top: wrapper.css("top"),
+				left: wrapper.css("left")
+			}).insertAfter( wrapper );
+			wrapper.remove();
+		}
+
+		this.originalElement.css("resize", this.originalResizeStyle);
+		_destroy(this.originalElement);
+
+		return this;
+	},
+
+	_mouseCapture: function(event) {
+		var i, handle,
+			capture = false;
+
+		for (i in this.handles) {
+			handle = $(this.handles[i])[0];
+			if (handle === event.target || $.contains(handle, event.target)) {
+				capture = true;
+			}
+		}
+
+		return !this.options.disabled && capture;
+	},
+
+	_mouseStart: function(event) {
+
+		var curleft, curtop, cursor,
+			o = this.options,
+			iniPos = this.element.position(),
+			el = this.element;
+
+		this.resizing = true;
+
+		// bugfix for http://dev.jquery.com/ticket/1749
+		if ( (/absolute/).test( el.css("position") ) ) {
+			el.css({ position: "absolute", top: el.css("top"), left: el.css("left") });
+		} else if (el.is(".ui-draggable")) {
+			el.css({ position: "absolute", top: iniPos.top, left: iniPos.left });
+		}
+
+		this._renderProxy();
+
+		curleft = num(this.helper.css("left"));
+		curtop = num(this.helper.css("top"));
+
+		if (o.containment) {
+			curleft += $(o.containment).scrollLeft() || 0;
+			curtop += $(o.containment).scrollTop() || 0;
+		}
+
+		//Store needed variables
+		this.offset = this.helper.offset();
+		this.position = { left: curleft, top: curtop };
+		this.size = this._helper ? { width: el.outerWidth(), height: el.outerHeight() } : { width: el.width(), height: el.height() };
+		this.originalSize = this._helper ? { width: el.outerWidth(), height: el.outerHeight() } : { width: el.width(), height: el.height() };
+		this.originalPosition = { left: curleft, top: curtop };
+		this.sizeDiff = { width: el.outerWidth() - el.width(), height: el.outerHeight() - el.height() };
+		this.originalMousePosition = { left: event.pageX, top: event.pageY };
+
+		//Aspect Ratio
+		this.aspectRatio = (typeof o.aspectRatio === "number") ? o.aspectRatio : ((this.originalSize.width / this.originalSize.height) || 1);
+
+		cursor = $(".ui-resizable-" + this.axis).css("cursor");
+		$("body").css("cursor", cursor === "auto" ? this.axis + "-resize" : cursor);
+
+		el.addClass("ui-resizable-resizing");
+		this._propagate("start", event);
+		return true;
+	},
+
+	_mouseDrag: function(event) {
+
+		//Increase performance, avoid regex
+		var data,
+			el = this.helper, props = {},
+			smp = this.originalMousePosition,
+			a = this.axis,
+			prevTop = this.position.top,
+			prevLeft = this.position.left,
+			prevWidth = this.size.width,
+			prevHeight = this.size.height,
+			dx = (event.pageX-smp.left)||0,
+			dy = (event.pageY-smp.top)||0,
+			trigger = this._change[a];
+
+		if (!trigger) {
+			return false;
+		}
+
+		// Calculate the attrs that will be change
+		data = trigger.apply(this, [event, dx, dy]);
+
+		// Put this in the mouseDrag handler since the user can start pressing shift while resizing
+		this._updateVirtualBoundaries(event.shiftKey);
+		if (this._aspectRatio || event.shiftKey) {
+			data = this._updateRatio(data, event);
+		}
+
+		data = this._respectSize(data, event);
+
+		this._updateCache(data);
+
+		// plugins callbacks need to be called first
+		this._propagate("resize", event);
+
+		if (this.position.top !== prevTop) {
+			props.top = this.position.top + "px";
+		}
+		if (this.position.left !== prevLeft) {
+			props.left = this.position.left + "px";
+		}
+		if (this.size.width !== prevWidth) {
+			props.width = this.size.width + "px";
+		}
+		if (this.size.height !== prevHeight) {
+			props.height = this.size.height + "px";
+		}
+		el.css(props);
+
+		if (!this._helper && this._proportionallyResizeElements.length) {
+			this._proportionallyResize();
+		}
+
+		// Call the user callback if the element was resized
+		if ( ! $.isEmptyObject(props) ) {
+			this._trigger("resize", event, this.ui());
+		}
+
+		return false;
+	},
+
+	_mouseStop: function(event) {
+
+		this.resizing = false;
+		var pr, ista, soffseth, soffsetw, s, left, top,
+			o = this.options, that = this;
+
+		if(this._helper) {
+
+			pr = this._proportionallyResizeElements;
+			ista = pr.length && (/textarea/i).test(pr[0].nodeName);
+			soffseth = ista && $.ui.hasScroll(pr[0], "left") /* TODO - jump height */ ? 0 : that.sizeDiff.height;
+			soffsetw = ista ? 0 : that.sizeDiff.width;
+
+			s = { width: (that.helper.width()  - soffsetw), height: (that.helper.height() - soffseth) };
+			left = (parseInt(that.element.css("left"), 10) + (that.position.left - that.originalPosition.left)) || null;
+			top = (parseInt(that.element.css("top"), 10) + (that.position.top - that.originalPosition.top)) || null;
+
+			if (!o.animate) {
+				this.element.css($.extend(s, { top: top, left: left }));
+			}
+
+			that.helper.height(that.size.height);
+			that.helper.width(that.size.width);
+
+			if (this._helper && !o.animate) {
+				this._proportionallyResize();
+			}
+		}
+
+		$("body").css("cursor", "auto");
+
+		this.element.removeClass("ui-resizable-resizing");
+
+		this._propagate("stop", event);
+
+		if (this._helper) {
+			this.helper.remove();
+		}
+
+		return false;
+
+	},
+
+	_updateVirtualBoundaries: function(forceAspectRatio) {
+		var pMinWidth, pMaxWidth, pMinHeight, pMaxHeight, b,
+			o = this.options;
+
+		b = {
+			minWidth: isNumber(o.minWidth) ? o.minWidth : 0,
+			maxWidth: isNumber(o.maxWidth) ? o.maxWidth : Infinity,
+			minHeight: isNumber(o.minHeight) ? o.minHeight : 0,
+			maxHeight: isNumber(o.maxHeight) ? o.maxHeight : Infinity
+		};
+
+		if(this._aspectRatio || forceAspectRatio) {
+			// We want to create an enclosing box whose aspect ration is the requested one
+			// First, compute the "projected" size for each dimension based on the aspect ratio and other dimension
+			pMinWidth = b.minHeight * this.aspectRatio;
+			pMinHeight = b.minWidth / this.aspectRatio;
+			pMaxWidth = b.maxHeight * this.aspectRatio;
+			pMaxHeight = b.maxWidth / this.aspectRatio;
+
+			if(pMinWidth > b.minWidth) {
+				b.minWidth = pMinWidth;
+			}
+			if(pMinHeight > b.minHeight) {
+				b.minHeight = pMinHeight;
+			}
+			if(pMaxWidth < b.maxWidth) {
+				b.maxWidth = pMaxWidth;
+			}
+			if(pMaxHeight < b.maxHeight) {
+				b.maxHeight = pMaxHeight;
+			}
+		}
+		this._vBoundaries = b;
+	},
+
+	_updateCache: function(data) {
+		this.offset = this.helper.offset();
+		if (isNumber(data.left)) {
+			this.position.left = data.left;
+		}
+		if (isNumber(data.top)) {
+			this.position.top = data.top;
+		}
+		if (isNumber(data.height)) {
+			this.size.height = data.height;
+		}
+		if (isNumber(data.width)) {
+			this.size.width = data.width;
+		}
+	},
+
+	_updateRatio: function( data ) {
+
+		var cpos = this.position,
+			csize = this.size,
+			a = this.axis;
+
+		if (isNumber(data.height)) {
+			data.width = (data.height * this.aspectRatio);
+		} else if (isNumber(data.width)) {
+			data.height = (data.width / this.aspectRatio);
+		}
+
+		if (a === "sw") {
+			data.left = cpos.left + (csize.width - data.width);
+			data.top = null;
+		}
+		if (a === "nw") {
+			data.top = cpos.top + (csize.height - data.height);
+			data.left = cpos.left + (csize.width - data.width);
+		}
+
+		return data;
+	},
+
+	_respectSize: function( data ) {
+
+		var o = this._vBoundaries,
+			a = this.axis,
+			ismaxw = isNumber(data.width) && o.maxWidth && (o.maxWidth < data.width), ismaxh = isNumber(data.height) && o.maxHeight && (o.maxHeight < data.height),
+			isminw = isNumber(data.width) && o.minWidth && (o.minWidth > data.width), isminh = isNumber(data.height) && o.minHeight && (o.minHeight > data.height),
+			dw = this.originalPosition.left + this.originalSize.width,
+			dh = this.position.top + this.size.height,
+			cw = /sw|nw|w/.test(a), ch = /nw|ne|n/.test(a);
+		if (isminw) {
+			data.width = o.minWidth;
+		}
+		if (isminh) {
+			data.height = o.minHeight;
+		}
+		if (ismaxw) {
+			data.width = o.maxWidth;
+		}
+		if (ismaxh) {
+			data.height = o.maxHeight;
+		}
+
+		if (isminw && cw) {
+			data.left = dw - o.minWidth;
+		}
+		if (ismaxw && cw) {
+			data.left = dw - o.maxWidth;
+		}
+		if (isminh && ch) {
+			data.top = dh - o.minHeight;
+		}
+		if (ismaxh && ch) {
+			data.top = dh - o.maxHeight;
+		}
+
+		// fixing jump error on top/left - bug #2330
+		if (!data.width && !data.height && !data.left && data.top) {
+			data.top = null;
+		} else if (!data.width && !data.height && !data.top && data.left) {
+			data.left = null;
+		}
+
+		return data;
+	},
+
+	_proportionallyResize: function() {
+
+		if (!this._proportionallyResizeElements.length) {
+			return;
+		}
+
+		var i, j, borders, paddings, prel,
+			element = this.helper || this.element;
+
+		for ( i=0; i < this._proportionallyResizeElements.length; i++) {
+
+			prel = this._proportionallyResizeElements[i];
+
+			if (!this.borderDif) {
+				this.borderDif = [];
+				borders = [prel.css("borderTopWidth"), prel.css("borderRightWidth"), prel.css("borderBottomWidth"), prel.css("borderLeftWidth")];
+				paddings = [prel.css("paddingTop"), prel.css("paddingRight"), prel.css("paddingBottom"), prel.css("paddingLeft")];
+
+				for ( j = 0; j < borders.length; j++ ) {
+					this.borderDif[ j ] = ( parseInt( borders[ j ], 10 ) || 0 ) + ( parseInt( paddings[ j ], 10 ) || 0 );
+				}
+			}
+
+			prel.css({
+				height: (element.height() - this.borderDif[0] - this.borderDif[2]) || 0,
+				width: (element.width() - this.borderDif[1] - this.borderDif[3]) || 0
+			});
+
+		}
+
+	},
+
+	_renderProxy: function() {
+
+		var el = this.element, o = this.options;
+		this.elementOffset = el.offset();
+
+		if(this._helper) {
+
+			this.helper = this.helper || $("<div style='overflow:hidden;'></div>");
+
+			this.helper.addClass(this._helper).css({
+				width: this.element.outerWidth() - 1,
+				height: this.element.outerHeight() - 1,
+				position: "absolute",
+				left: this.elementOffset.left +"px",
+				top: this.elementOffset.top +"px",
+				zIndex: ++o.zIndex //TODO: Don't modify option
+			});
+
+			this.helper
+				.appendTo("body")
+				.disableSelection();
+
+		} else {
+			this.helper = this.element;
+		}
+
+	},
+
+	_change: {
+		e: function(event, dx) {
+			return { width: this.originalSize.width + dx };
+		},
+		w: function(event, dx) {
+			var cs = this.originalSize, sp = this.originalPosition;
+			return { left: sp.left + dx, width: cs.width - dx };
+		},
+		n: function(event, dx, dy) {
+			var cs = this.originalSize, sp = this.originalPosition;
+			return { top: sp.top + dy, height: cs.height - dy };
+		},
+		s: function(event, dx, dy) {
+			return { height: this.originalSize.height + dy };
+		},
+		se: function(event, dx, dy) {
+			return $.extend(this._change.s.apply(this, arguments), this._change.e.apply(this, [event, dx, dy]));
+		},
+		sw: function(event, dx, dy) {
+			return $.extend(this._change.s.apply(this, arguments), this._change.w.apply(this, [event, dx, dy]));
+		},
+		ne: function(event, dx, dy) {
+			return $.extend(this._change.n.apply(this, arguments), this._change.e.apply(this, [event, dx, dy]));
+		},
+		nw: function(event, dx, dy) {
+			return $.extend(this._change.n.apply(this, arguments), this._change.w.apply(this, [event, dx, dy]));
+		}
+	},
+
+	_propagate: function(n, event) {
+		$.ui.plugin.call(this, n, [event, this.ui()]);
+		(n !== "resize" && this._trigger(n, event, this.ui()));
+	},
+
+	plugins: {},
+
+	ui: function() {
+		return {
+			originalElement: this.originalElement,
+			element: this.element,
+			helper: this.helper,
+			position: this.position,
+			size: this.size,
+			originalSize: this.originalSize,
+			originalPosition: this.originalPosition
+		};
+	}
+
+});
+
+/*
+ * Resizable Extensions
+ */
+
+$.ui.plugin.add("resizable", "animate", {
+
+	stop: function( event ) {
+		var that = $(this).data("ui-resizable"),
+			o = that.options,
+			pr = that._proportionallyResizeElements,
+			ista = pr.length && (/textarea/i).test(pr[0].nodeName),
+			soffseth = ista && $.ui.hasScroll(pr[0], "left") /* TODO - jump height */ ? 0 : that.sizeDiff.height,
+			soffsetw = ista ? 0 : that.sizeDiff.width,
+			style = { width: (that.size.width - soffsetw), height: (that.size.height - soffseth) },
+			left = (parseInt(that.element.css("left"), 10) + (that.position.left - that.originalPosition.left)) || null,
+			top = (parseInt(that.element.css("top"), 10) + (that.position.top - that.originalPosition.top)) || null;
+
+		that.element.animate(
+			$.extend(style, top && left ? { top: top, left: left } : {}), {
+				duration: o.animateDuration,
+				easing: o.animateEasing,
+				step: function() {
+
+					var data = {
+						width: parseInt(that.element.css("width"), 10),
+						height: parseInt(that.element.css("height"), 10),
+						top: parseInt(that.element.css("top"), 10),
+						left: parseInt(that.element.css("left"), 10)
+					};
+
+					if (pr && pr.length) {
+						$(pr[0]).css({ width: data.width, height: data.height });
+					}
+
+					// propagating resize, and updating values for each animation step
+					that._updateCache(data);
+					that._propagate("resize", event);
+
+				}
+			}
+		);
+	}
+
+});
+
+$.ui.plugin.add("resizable", "containment", {
+
+	start: function() {
+		var element, p, co, ch, cw, width, height,
+			that = $(this).data("ui-resizable"),
+			o = that.options,
+			el = that.element,
+			oc = o.containment,
+			ce = (oc instanceof $) ? oc.get(0) : (/parent/.test(oc)) ? el.parent().get(0) : oc;
+
+		if (!ce) {
+			return;
+		}
+
+		that.containerElement = $(ce);
+
+		if (/document/.test(oc) || oc === document) {
+			that.containerOffset = { left: 0, top: 0 };
+			that.containerPosition = { left: 0, top: 0 };
+
+			that.parentData = {
+				element: $(document), left: 0, top: 0,
+				width: $(document).width(), height: $(document).height() || document.body.parentNode.scrollHeight
+			};
+		}
+
+		// i'm a node, so compute top, left, right, bottom
+		else {
+			element = $(ce);
+			p = [];
+			$([ "Top", "Right", "Left", "Bottom" ]).each(function(i, name) { p[i] = num(element.css("padding" + name)); });
+
+			that.containerOffset = element.offset();
+			that.containerPosition = element.position();
+			that.containerSize = { height: (element.innerHeight() - p[3]), width: (element.innerWidth() - p[1]) };
+
+			co = that.containerOffset;
+			ch = that.containerSize.height;
+			cw = that.containerSize.width;
+			width = ($.ui.hasScroll(ce, "left") ? ce.scrollWidth : cw );
+			height = ($.ui.hasScroll(ce) ? ce.scrollHeight : ch);
+
+			that.parentData = {
+				element: ce, left: co.left, top: co.top, width: width, height: height
+			};
+		}
+	},
+
+	resize: function( event ) {
+		var woset, hoset, isParent, isOffsetRelative,
+			that = $(this).data("ui-resizable"),
+			o = that.options,
+			co = that.containerOffset, cp = that.position,
+			pRatio = that._aspectRatio || event.shiftKey,
+			cop = { top:0, left:0 }, ce = that.containerElement;
+
+		if (ce[0] !== document && (/static/).test(ce.css("position"))) {
+			cop = co;
+		}
+
+		if (cp.left < (that._helper ? co.left : 0)) {
+			that.size.width = that.size.width + (that._helper ? (that.position.left - co.left) : (that.position.left - cop.left));
+			if (pRatio) {
+				that.size.height = that.size.width / that.aspectRatio;
+			}
+			that.position.left = o.helper ? co.left : 0;
+		}
+
+		if (cp.top < (that._helper ? co.top : 0)) {
+			that.size.height = that.size.height + (that._helper ? (that.position.top - co.top) : that.position.top);
+			if (pRatio) {
+				that.size.width = that.size.height * that.aspectRatio;
+			}
+			that.position.top = that._helper ? co.top : 0;
+		}
+
+		that.offset.left = that.parentData.left+that.position.left;
+		that.offset.top = that.parentData.top+that.position.top;
+
+		woset = Math.abs( (that._helper ? that.offset.left - cop.left : (that.offset.left - cop.left)) + that.sizeDiff.width );
+		hoset = Math.abs( (that._helper ? that.offset.top - cop.top : (that.offset.top - co.top)) + that.sizeDiff.height );
+
+		isParent = that.containerElement.get(0) === that.element.parent().get(0);
+		isOffsetRelative = /relative|absolute/.test(that.containerElement.css("position"));
+
+		if(isParent && isOffsetRelative) {
+			woset -= that.parentData.left;
+		}
+
+		if (woset + that.size.width >= that.parentData.width) {
+			that.size.width = that.parentData.width - woset;
+			if (pRatio) {
+				that.size.height = that.size.width / that.aspectRatio;
+			}
+		}
+
+		if (hoset + that.size.height >= that.parentData.height) {
+			that.size.height = that.parentData.height - hoset;
+			if (pRatio) {
+				that.size.width = that.size.height * that.aspectRatio;
+			}
+		}
+	},
+
+	stop: function(){
+		var that = $(this).data("ui-resizable"),
+			o = that.options,
+			co = that.containerOffset,
+			cop = that.containerPosition,
+			ce = that.containerElement,
+			helper = $(that.helper),
+			ho = helper.offset(),
+			w = helper.outerWidth() - that.sizeDiff.width,
+			h = helper.outerHeight() - that.sizeDiff.height;
+
+		if (that._helper && !o.animate && (/relative/).test(ce.css("position"))) {
+			$(this).css({ left: ho.left - cop.left - co.left, width: w, height: h });
+		}
+
+		if (that._helper && !o.animate && (/static/).test(ce.css("position"))) {
+			$(this).css({ left: ho.left - cop.left - co.left, width: w, height: h });
+		}
+
+	}
+});
+
+$.ui.plugin.add("resizable", "alsoResize", {
+
+	start: function () {
+		var that = $(this).data("ui-resizable"),
+			o = that.options,
+			_store = function (exp) {
+				$(exp).each(function() {
+					var el = $(this);
+					el.data("ui-resizable-alsoresize", {
+						width: parseInt(el.width(), 10), height: parseInt(el.height(), 10),
+						left: parseInt(el.css("left"), 10), top: parseInt(el.css("top"), 10)
+					});
+				});
+			};
+
+		if (typeof(o.alsoResize) === "object" && !o.alsoResize.parentNode) {
+			if (o.alsoResize.length) { o.alsoResize = o.alsoResize[0]; _store(o.alsoResize); }
+			else { $.each(o.alsoResize, function (exp) { _store(exp); }); }
+		}else{
+			_store(o.alsoResize);
+		}
+	},
+
+	resize: function (event, ui) {
+		var that = $(this).data("ui-resizable"),
+			o = that.options,
+			os = that.originalSize,
+			op = that.originalPosition,
+			delta = {
+				height: (that.size.height - os.height) || 0, width: (that.size.width - os.width) || 0,
+				top: (that.position.top - op.top) || 0, left: (that.position.left - op.left) || 0
+			},
+
+			_alsoResize = function (exp, c) {
+				$(exp).each(function() {
+					var el = $(this), start = $(this).data("ui-resizable-alsoresize"), style = {},
+						css = c && c.length ? c : el.parents(ui.originalElement[0]).length ? ["width", "height"] : ["width", "height", "top", "left"];
+
+					$.each(css, function (i, prop) {
+						var sum = (start[prop]||0) + (delta[prop]||0);
+						if (sum && sum >= 0) {
+							style[prop] = sum || null;
+						}
+					});
+
+					el.css(style);
+				});
+			};
+
+		if (typeof(o.alsoResize) === "object" && !o.alsoResize.nodeType) {
+			$.each(o.alsoResize, function (exp, c) { _alsoResize(exp, c); });
+		}else{
+			_alsoResize(o.alsoResize);
+		}
+	},
+
+	stop: function () {
+		$(this).removeData("resizable-alsoresize");
+	}
+});
+
+$.ui.plugin.add("resizable", "ghost", {
+
+	start: function() {
+
+		var that = $(this).data("ui-resizable"), o = that.options, cs = that.size;
+
+		that.ghost = that.originalElement.clone();
+		that.ghost
+			.css({ opacity: 0.25, display: "block", position: "relative", height: cs.height, width: cs.width, margin: 0, left: 0, top: 0 })
+			.addClass("ui-resizable-ghost")
+			.addClass(typeof o.ghost === "string" ? o.ghost : "");
+
+		that.ghost.appendTo(that.helper);
+
+	},
+
+	resize: function(){
+		var that = $(this).data("ui-resizable");
+		if (that.ghost) {
+			that.ghost.css({ position: "relative", height: that.size.height, width: that.size.width });
+		}
+	},
+
+	stop: function() {
+		var that = $(this).data("ui-resizable");
+		if (that.ghost && that.helper) {
+			that.helper.get(0).removeChild(that.ghost.get(0));
+		}
+	}
+
+});
+
+$.ui.plugin.add("resizable", "grid", {
+
+	resize: function() {
+		var that = $(this).data("ui-resizable"),
+			o = that.options,
+			cs = that.size,
+			os = that.originalSize,
+			op = that.originalPosition,
+			a = that.axis,
+			grid = typeof o.grid === "number" ? [o.grid, o.grid] : o.grid,
+			gridX = (grid[0]||1),
+			gridY = (grid[1]||1),
+			ox = Math.round((cs.width - os.width) / gridX) * gridX,
+			oy = Math.round((cs.height - os.height) / gridY) * gridY,
+			newWidth = os.width + ox,
+			newHeight = os.height + oy,
+			isMaxWidth = o.maxWidth && (o.maxWidth < newWidth),
+			isMaxHeight = o.maxHeight && (o.maxHeight < newHeight),
+			isMinWidth = o.minWidth && (o.minWidth > newWidth),
+			isMinHeight = o.minHeight && (o.minHeight > newHeight);
+
+		o.grid = grid;
+
+		if (isMinWidth) {
+			newWidth = newWidth + gridX;
+		}
+		if (isMinHeight) {
+			newHeight = newHeight + gridY;
+		}
+		if (isMaxWidth) {
+			newWidth = newWidth - gridX;
+		}
+		if (isMaxHeight) {
+			newHeight = newHeight - gridY;
+		}
+
+		if (/^(se|s|e)$/.test(a)) {
+			that.size.width = newWidth;
+			that.size.height = newHeight;
+		} else if (/^(ne)$/.test(a)) {
+			that.size.width = newWidth;
+			that.size.height = newHeight;
+			that.position.top = op.top - oy;
+		} else if (/^(sw)$/.test(a)) {
+			that.size.width = newWidth;
+			that.size.height = newHeight;
+			that.position.left = op.left - ox;
+		} else {
+			that.size.width = newWidth;
+			that.size.height = newHeight;
+			that.position.top = op.top - oy;
+			that.position.left = op.left - ox;
+		}
+	}
+
+});
+
+})(jQuery);
+
+});
\ No newline at end of file
diff --git a/module/web/static/js/libs/jqueryui/selectable.js b/module/web/static/js/libs/jqueryui/selectable.js
new file mode 100644
index 000000000..e644c989e
--- /dev/null
+++ b/module/web/static/js/libs/jqueryui/selectable.js
@@ -0,0 +1,280 @@
+define(['jquery','./core','./mouse','./widget'], function (jQuery) {
+/*!
+ * jQuery UI Selectable 1.10.1
+ * http://jqueryui.com
+ *
+ * Copyright 2013 jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ *
+ * http://api.jqueryui.com/selectable/
+ *
+ * Depends:
+ *	jquery.ui.core.js
+ *	jquery.ui.mouse.js
+ *	jquery.ui.widget.js
+ */
+(function( $, undefined ) {
+
+$.widget("ui.selectable", $.ui.mouse, {
+	version: "1.10.1",
+	options: {
+		appendTo: "body",
+		autoRefresh: true,
+		distance: 0,
+		filter: "*",
+		tolerance: "touch",
+
+		// callbacks
+		selected: null,
+		selecting: null,
+		start: null,
+		stop: null,
+		unselected: null,
+		unselecting: null
+	},
+	_create: function() {
+		var selectees,
+			that = this;
+
+		this.element.addClass("ui-selectable");
+
+		this.dragged = false;
+
+		// cache selectee children based on filter
+		this.refresh = function() {
+			selectees = $(that.options.filter, that.element[0]);
+			selectees.addClass("ui-selectee");
+			selectees.each(function() {
+				var $this = $(this),
+					pos = $this.offset();
+				$.data(this, "selectable-item", {
+					element: this,
+					$element: $this,
+					left: pos.left,
+					top: pos.top,
+					right: pos.left + $this.outerWidth(),
+					bottom: pos.top + $this.outerHeight(),
+					startselected: false,
+					selected: $this.hasClass("ui-selected"),
+					selecting: $this.hasClass("ui-selecting"),
+					unselecting: $this.hasClass("ui-unselecting")
+				});
+			});
+		};
+		this.refresh();
+
+		this.selectees = selectees.addClass("ui-selectee");
+
+		this._mouseInit();
+
+		this.helper = $("<div class='ui-selectable-helper'></div>");
+	},
+
+	_destroy: function() {
+		this.selectees
+			.removeClass("ui-selectee")
+			.removeData("selectable-item");
+		this.element
+			.removeClass("ui-selectable ui-selectable-disabled");
+		this._mouseDestroy();
+	},
+
+	_mouseStart: function(event) {
+		var that = this,
+			options = this.options;
+
+		this.opos = [event.pageX, event.pageY];
+
+		if (this.options.disabled) {
+			return;
+		}
+
+		this.selectees = $(options.filter, this.element[0]);
+
+		this._trigger("start", event);
+
+		$(options.appendTo).append(this.helper);
+		// position helper (lasso)
+		this.helper.css({
+			"left": event.pageX,
+			"top": event.pageY,
+			"width": 0,
+			"height": 0
+		});
+
+		if (options.autoRefresh) {
+			this.refresh();
+		}
+
+		this.selectees.filter(".ui-selected").each(function() {
+			var selectee = $.data(this, "selectable-item");
+			selectee.startselected = true;
+			if (!event.metaKey && !event.ctrlKey) {
+				selectee.$element.removeClass("ui-selected");
+				selectee.selected = false;
+				selectee.$element.addClass("ui-unselecting");
+				selectee.unselecting = true;
+				// selectable UNSELECTING callback
+				that._trigger("unselecting", event, {
+					unselecting: selectee.element
+				});
+			}
+		});
+
+		$(event.target).parents().addBack().each(function() {
+			var doSelect,
+				selectee = $.data(this, "selectable-item");
+			if (selectee) {
+				doSelect = (!event.metaKey && !event.ctrlKey) || !selectee.$element.hasClass("ui-selected");
+				selectee.$element
+					.removeClass(doSelect ? "ui-unselecting" : "ui-selected")
+					.addClass(doSelect ? "ui-selecting" : "ui-unselecting");
+				selectee.unselecting = !doSelect;
+				selectee.selecting = doSelect;
+				selectee.selected = doSelect;
+				// selectable (UN)SELECTING callback
+				if (doSelect) {
+					that._trigger("selecting", event, {
+						selecting: selectee.element
+					});
+				} else {
+					that._trigger("unselecting", event, {
+						unselecting: selectee.element
+					});
+				}
+				return false;
+			}
+		});
+
+	},
+
+	_mouseDrag: function(event) {
+
+		this.dragged = true;
+
+		if (this.options.disabled) {
+			return;
+		}
+
+		var tmp,
+			that = this,
+			options = this.options,
+			x1 = this.opos[0],
+			y1 = this.opos[1],
+			x2 = event.pageX,
+			y2 = event.pageY;
+
+		if (x1 > x2) { tmp = x2; x2 = x1; x1 = tmp; }
+		if (y1 > y2) { tmp = y2; y2 = y1; y1 = tmp; }
+		this.helper.css({left: x1, top: y1, width: x2-x1, height: y2-y1});
+
+		this.selectees.each(function() {
+			var selectee = $.data(this, "selectable-item"),
+				hit = false;
+
+			//prevent helper from being selected if appendTo: selectable
+			if (!selectee || selectee.element === that.element[0]) {
+				return;
+			}
+
+			if (options.tolerance === "touch") {
+				hit = ( !(selectee.left > x2 || selectee.right < x1 || selectee.top > y2 || selectee.bottom < y1) );
+			} else if (options.tolerance === "fit") {
+				hit = (selectee.left > x1 && selectee.right < x2 && selectee.top > y1 && selectee.bottom < y2);
+			}
+
+			if (hit) {
+				// SELECT
+				if (selectee.selected) {
+					selectee.$element.removeClass("ui-selected");
+					selectee.selected = false;
+				}
+				if (selectee.unselecting) {
+					selectee.$element.removeClass("ui-unselecting");
+					selectee.unselecting = false;
+				}
+				if (!selectee.selecting) {
+					selectee.$element.addClass("ui-selecting");
+					selectee.selecting = true;
+					// selectable SELECTING callback
+					that._trigger("selecting", event, {
+						selecting: selectee.element
+					});
+				}
+			} else {
+				// UNSELECT
+				if (selectee.selecting) {
+					if ((event.metaKey || event.ctrlKey) && selectee.startselected) {
+						selectee.$element.removeClass("ui-selecting");
+						selectee.selecting = false;
+						selectee.$element.addClass("ui-selected");
+						selectee.selected = true;
+					} else {
+						selectee.$element.removeClass("ui-selecting");
+						selectee.selecting = false;
+						if (selectee.startselected) {
+							selectee.$element.addClass("ui-unselecting");
+							selectee.unselecting = true;
+						}
+						// selectable UNSELECTING callback
+						that._trigger("unselecting", event, {
+							unselecting: selectee.element
+						});
+					}
+				}
+				if (selectee.selected) {
+					if (!event.metaKey && !event.ctrlKey && !selectee.startselected) {
+						selectee.$element.removeClass("ui-selected");
+						selectee.selected = false;
+
+						selectee.$element.addClass("ui-unselecting");
+						selectee.unselecting = true;
+						// selectable UNSELECTING callback
+						that._trigger("unselecting", event, {
+							unselecting: selectee.element
+						});
+					}
+				}
+			}
+		});
+
+		return false;
+	},
+
+	_mouseStop: function(event) {
+		var that = this;
+
+		this.dragged = false;
+
+		$(".ui-unselecting", this.element[0]).each(function() {
+			var selectee = $.data(this, "selectable-item");
+			selectee.$element.removeClass("ui-unselecting");
+			selectee.unselecting = false;
+			selectee.startselected = false;
+			that._trigger("unselected", event, {
+				unselected: selectee.element
+			});
+		});
+		$(".ui-selecting", this.element[0]).each(function() {
+			var selectee = $.data(this, "selectable-item");
+			selectee.$element.removeClass("ui-selecting").addClass("ui-selected");
+			selectee.selecting = false;
+			selectee.selected = true;
+			selectee.startselected = true;
+			that._trigger("selected", event, {
+				selected: selectee.element
+			});
+		});
+		this._trigger("stop", event);
+
+		this.helper.remove();
+
+		return false;
+	}
+
+});
+
+})(jQuery);
+
+});
\ No newline at end of file
diff --git a/module/web/static/js/libs/jqueryui/sortable.js b/module/web/static/js/libs/jqueryui/sortable.js
new file mode 100644
index 000000000..3d58c0729
--- /dev/null
+++ b/module/web/static/js/libs/jqueryui/sortable.js
@@ -0,0 +1,1253 @@
+define(['jquery','./core','./mouse','./widget'], function (jQuery) {
+/*!
+ * jQuery UI Sortable 1.10.1
+ * http://jqueryui.com
+ *
+ * Copyright 2013 jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ *
+ * http://api.jqueryui.com/sortable/
+ *
+ * Depends:
+ *	jquery.ui.core.js
+ *	jquery.ui.mouse.js
+ *	jquery.ui.widget.js
+ */
+(function( $, undefined ) {
+
+/*jshint loopfunc: true */
+
+function isOverAxis( x, reference, size ) {
+	return ( x > reference ) && ( x < ( reference + size ) );
+}
+
+$.widget("ui.sortable", $.ui.mouse, {
+	version: "1.10.1",
+	widgetEventPrefix: "sort",
+	ready: false,
+	options: {
+		appendTo: "parent",
+		axis: false,
+		connectWith: false,
+		containment: false,
+		cursor: "auto",
+		cursorAt: false,
+		dropOnEmpty: true,
+		forcePlaceholderSize: false,
+		forceHelperSize: false,
+		grid: false,
+		handle: false,
+		helper: "original",
+		items: "> *",
+		opacity: false,
+		placeholder: false,
+		revert: false,
+		scroll: true,
+		scrollSensitivity: 20,
+		scrollSpeed: 20,
+		scope: "default",
+		tolerance: "intersect",
+		zIndex: 1000,
+
+		// callbacks
+		activate: null,
+		beforeStop: null,
+		change: null,
+		deactivate: null,
+		out: null,
+		over: null,
+		receive: null,
+		remove: null,
+		sort: null,
+		start: null,
+		stop: null,
+		update: null
+	},
+	_create: function() {
+
+		var o = this.options;
+		this.containerCache = {};
+		this.element.addClass("ui-sortable");
+
+		//Get the items
+		this.refresh();
+
+		//Let's determine if the items are being displayed horizontally
+		this.floating = this.items.length ? o.axis === "x" || (/left|right/).test(this.items[0].item.css("float")) || (/inline|table-cell/).test(this.items[0].item.css("display")) : false;
+
+		//Let's determine the parent's offset
+		this.offset = this.element.offset();
+
+		//Initialize mouse events for interaction
+		this._mouseInit();
+
+		//We're ready to go
+		this.ready = true;
+
+	},
+
+	_destroy: function() {
+		this.element
+			.removeClass("ui-sortable ui-sortable-disabled");
+		this._mouseDestroy();
+
+		for ( var i = this.items.length - 1; i >= 0; i-- ) {
+			this.items[i].item.removeData(this.widgetName + "-item");
+		}
+
+		return this;
+	},
+
+	_setOption: function(key, value){
+		if ( key === "disabled" ) {
+			this.options[ key ] = value;
+
+			this.widget().toggleClass( "ui-sortable-disabled", !!value );
+		} else {
+			// Don't call widget base _setOption for disable as it adds ui-state-disabled class
+			$.Widget.prototype._setOption.apply(this, arguments);
+		}
+	},
+
+	_mouseCapture: function(event, overrideHandle) {
+		var currentItem = null,
+			validHandle = false,
+			that = this;
+
+		if (this.reverting) {
+			return false;
+		}
+
+		if(this.options.disabled || this.options.type === "static") {
+			return false;
+		}
+
+		//We have to refresh the items data once first
+		this._refreshItems(event);
+
+		//Find out if the clicked node (or one of its parents) is a actual item in this.items
+		$(event.target).parents().each(function() {
+			if($.data(this, that.widgetName + "-item") === that) {
+				currentItem = $(this);
+				return false;
+			}
+		});
+		if($.data(event.target, that.widgetName + "-item") === that) {
+			currentItem = $(event.target);
+		}
+
+		if(!currentItem) {
+			return false;
+		}
+		if(this.options.handle && !overrideHandle) {
+			$(this.options.handle, currentItem).find("*").addBack().each(function() {
+				if(this === event.target) {
+					validHandle = true;
+				}
+			});
+			if(!validHandle) {
+				return false;
+			}
+		}
+
+		this.currentItem = currentItem;
+		this._removeCurrentsFromItems();
+		return true;
+
+	},
+
+	_mouseStart: function(event, overrideHandle, noActivation) {
+
+		var i,
+			o = this.options;
+
+		this.currentContainer = this;
+
+		//We only need to call refreshPositions, because the refreshItems call has been moved to mouseCapture
+		this.refreshPositions();
+
+		//Create and append the visible helper
+		this.helper = this._createHelper(event);
+
+		//Cache the helper size
+		this._cacheHelperProportions();
+
+		/*
+		 * - Position generation -
+		 * This block generates everything position related - it's the core of draggables.
+		 */
+
+		//Cache the margins of the original element
+		this._cacheMargins();
+
+		//Get the next scrolling parent
+		this.scrollParent = this.helper.scrollParent();
+
+		//The element's absolute position on the page minus margins
+		this.offset = this.currentItem.offset();
+		this.offset = {
+			top: this.offset.top - this.margins.top,
+			left: this.offset.left - this.margins.left
+		};
+
+		$.extend(this.offset, {
+			click: { //Where the click happened, relative to the element
+				left: event.pageX - this.offset.left,
+				top: event.pageY - this.offset.top
+			},
+			parent: this._getParentOffset(),
+			relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
+		});
+
+		// Only after we got the offset, we can change the helper's position to absolute
+		// TODO: Still need to figure out a way to make relative sorting possible
+		this.helper.css("position", "absolute");
+		this.cssPosition = this.helper.css("position");
+
+		//Generate the original position
+		this.originalPosition = this._generatePosition(event);
+		this.originalPageX = event.pageX;
+		this.originalPageY = event.pageY;
+
+		//Adjust the mouse offset relative to the helper if "cursorAt" is supplied
+		(o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
+
+		//Cache the former DOM position
+		this.domPosition = { prev: this.currentItem.prev()[0], parent: this.currentItem.parent()[0] };
+
+		//If the helper is not the original, hide the original so it's not playing any role during the drag, won't cause anything bad this way
+		if(this.helper[0] !== this.currentItem[0]) {
+			this.currentItem.hide();
+		}
+
+		//Create the placeholder
+		this._createPlaceholder();
+
+		//Set a containment if given in the options
+		if(o.containment) {
+			this._setContainment();
+		}
+
+		if(o.cursor) { // cursor option
+			if ($("body").css("cursor")) {
+				this._storedCursor = $("body").css("cursor");
+			}
+			$("body").css("cursor", o.cursor);
+		}
+
+		if(o.opacity) { // opacity option
+			if (this.helper.css("opacity")) {
+				this._storedOpacity = this.helper.css("opacity");
+			}
+			this.helper.css("opacity", o.opacity);
+		}
+
+		if(o.zIndex) { // zIndex option
+			if (this.helper.css("zIndex")) {
+				this._storedZIndex = this.helper.css("zIndex");
+			}
+			this.helper.css("zIndex", o.zIndex);
+		}
+
+		//Prepare scrolling
+		if(this.scrollParent[0] !== document && this.scrollParent[0].tagName !== "HTML") {
+			this.overflowOffset = this.scrollParent.offset();
+		}
+
+		//Call callbacks
+		this._trigger("start", event, this._uiHash());
+
+		//Recache the helper size
+		if(!this._preserveHelperProportions) {
+			this._cacheHelperProportions();
+		}
+
+
+		//Post "activate" events to possible containers
+		if( !noActivation ) {
+			for ( i = this.containers.length - 1; i >= 0; i-- ) {
+				this.containers[ i ]._trigger( "activate", event, this._uiHash( this ) );
+			}
+		}
+
+		//Prepare possible droppables
+		if($.ui.ddmanager) {
+			$.ui.ddmanager.current = this;
+		}
+
+		if ($.ui.ddmanager && !o.dropBehaviour) {
+			$.ui.ddmanager.prepareOffsets(this, event);
+		}
+
+		this.dragging = true;
+
+		this.helper.addClass("ui-sortable-helper");
+		this._mouseDrag(event); //Execute the drag once - this causes the helper not to be visible before getting its correct position
+		return true;
+
+	},
+
+	_mouseDrag: function(event) {
+		var i, item, itemElement, intersection,
+			o = this.options,
+			scrolled = false;
+
+		//Compute the helpers position
+		this.position = this._generatePosition(event);
+		this.positionAbs = this._convertPositionTo("absolute");
+
+		if (!this.lastPositionAbs) {
+			this.lastPositionAbs = this.positionAbs;
+		}
+
+		//Do scrolling
+		if(this.options.scroll) {
+			if(this.scrollParent[0] !== document && this.scrollParent[0].tagName !== "HTML") {
+
+				if((this.overflowOffset.top + this.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity) {
+					this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop + o.scrollSpeed;
+				} else if(event.pageY - this.overflowOffset.top < o.scrollSensitivity) {
+					this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop - o.scrollSpeed;
+				}
+
+				if((this.overflowOffset.left + this.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity) {
+					this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft + o.scrollSpeed;
+				} else if(event.pageX - this.overflowOffset.left < o.scrollSensitivity) {
+					this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft - o.scrollSpeed;
+				}
+
+			} else {
+
+				if(event.pageY - $(document).scrollTop() < o.scrollSensitivity) {
+					scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
+				} else if($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity) {
+					scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
+				}
+
+				if(event.pageX - $(document).scrollLeft() < o.scrollSensitivity) {
+					scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
+				} else if($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity) {
+					scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
+				}
+
+			}
+
+			if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) {
+				$.ui.ddmanager.prepareOffsets(this, event);
+			}
+		}
+
+		//Regenerate the absolute position used for position checks
+		this.positionAbs = this._convertPositionTo("absolute");
+
+		//Set the helper position
+		if(!this.options.axis || this.options.axis !== "y") {
+			this.helper[0].style.left = this.position.left+"px";
+		}
+		if(!this.options.axis || this.options.axis !== "x") {
+			this.helper[0].style.top = this.position.top+"px";
+		}
+
+		//Rearrange
+		for (i = this.items.length - 1; i >= 0; i--) {
+
+			//Cache variables and intersection, continue if no intersection
+			item = this.items[i];
+			itemElement = item.item[0];
+			intersection = this._intersectsWithPointer(item);
+			if (!intersection) {
+				continue;
+			}
+
+			// Only put the placeholder inside the current Container, skip all
+			// items form other containers. This works because when moving
+			// an item from one container to another the
+			// currentContainer is switched before the placeholder is moved.
+			//
+			// Without this moving items in "sub-sortables" can cause the placeholder to jitter
+			// beetween the outer and inner container.
+			if (item.instance !== this.currentContainer) {
+				continue;
+			}
+
+			// cannot intersect with itself
+			// no useless actions that have been done before
+			// no action if the item moved is the parent of the item checked
+			if (itemElement !== this.currentItem[0] &&
+				this.placeholder[intersection === 1 ? "next" : "prev"]()[0] !== itemElement &&
+				!$.contains(this.placeholder[0], itemElement) &&
+				(this.options.type === "semi-dynamic" ? !$.contains(this.element[0], itemElement) : true)
+			) {
+
+				this.direction = intersection === 1 ? "down" : "up";
+
+				if (this.options.tolerance === "pointer" || this._intersectsWithSides(item)) {
+					this._rearrange(event, item);
+				} else {
+					break;
+				}
+
+				this._trigger("change", event, this._uiHash());
+				break;
+			}
+		}
+
+		//Post events to containers
+		this._contactContainers(event);
+
+		//Interconnect with droppables
+		if($.ui.ddmanager) {
+			$.ui.ddmanager.drag(this, event);
+		}
+
+		//Call callbacks
+		this._trigger("sort", event, this._uiHash());
+
+		this.lastPositionAbs = this.positionAbs;
+		return false;
+
+	},
+
+	_mouseStop: function(event, noPropagation) {
+
+		if(!event) {
+			return;
+		}
+
+		//If we are using droppables, inform the manager about the drop
+		if ($.ui.ddmanager && !this.options.dropBehaviour) {
+			$.ui.ddmanager.drop(this, event);
+		}
+
+		if(this.options.revert) {
+			var that = this,
+				cur = this.placeholder.offset();
+
+			this.reverting = true;
+
+			$(this.helper).animate({
+				left: cur.left - this.offset.parent.left - this.margins.left + (this.offsetParent[0] === document.body ? 0 : this.offsetParent[0].scrollLeft),
+				top: cur.top - this.offset.parent.top - this.margins.top + (this.offsetParent[0] === document.body ? 0 : this.offsetParent[0].scrollTop)
+			}, parseInt(this.options.revert, 10) || 500, function() {
+				that._clear(event);
+			});
+		} else {
+			this._clear(event, noPropagation);
+		}
+
+		return false;
+
+	},
+
+	cancel: function() {
+
+		if(this.dragging) {
+
+			this._mouseUp({ target: null });
+
+			if(this.options.helper === "original") {
+				this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
+			} else {
+				this.currentItem.show();
+			}
+
+			//Post deactivating events to containers
+			for (var i = this.containers.length - 1; i >= 0; i--){
+				this.containers[i]._trigger("deactivate", null, this._uiHash(this));
+				if(this.containers[i].containerCache.over) {
+					this.containers[i]._trigger("out", null, this._uiHash(this));
+					this.containers[i].containerCache.over = 0;
+				}
+			}
+
+		}
+
+		if (this.placeholder) {
+			//$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
+			if(this.placeholder[0].parentNode) {
+				this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
+			}
+			if(this.options.helper !== "original" && this.helper && this.helper[0].parentNode) {
+				this.helper.remove();
+			}
+
+			$.extend(this, {
+				helper: null,
+				dragging: false,
+				reverting: false,
+				_noFinalSort: null
+			});
+
+			if(this.domPosition.prev) {
+				$(this.domPosition.prev).after(this.currentItem);
+			} else {
+				$(this.domPosition.parent).prepend(this.currentItem);
+			}
+		}
+
+		return this;
+
+	},
+
+	serialize: function(o) {
+
+		var items = this._getItemsAsjQuery(o && o.connected),
+			str = [];
+		o = o || {};
+
+		$(items).each(function() {
+			var res = ($(o.item || this).attr(o.attribute || "id") || "").match(o.expression || (/(.+)[\-=_](.+)/));
+			if (res) {
+				str.push((o.key || res[1]+"[]")+"="+(o.key && o.expression ? res[1] : res[2]));
+			}
+		});
+
+		if(!str.length && o.key) {
+			str.push(o.key + "=");
+		}
+
+		return str.join("&");
+
+	},
+
+	toArray: function(o) {
+
+		var items = this._getItemsAsjQuery(o && o.connected),
+			ret = [];
+
+		o = o || {};
+
+		items.each(function() { ret.push($(o.item || this).attr(o.attribute || "id") || ""); });
+		return ret;
+
+	},
+
+	/* Be careful with the following core functions */
+	_intersectsWith: function(item) {
+
+		var x1 = this.positionAbs.left,
+			x2 = x1 + this.helperProportions.width,
+			y1 = this.positionAbs.top,
+			y2 = y1 + this.helperProportions.height,
+			l = item.left,
+			r = l + item.width,
+			t = item.top,
+			b = t + item.height,
+			dyClick = this.offset.click.top,
+			dxClick = this.offset.click.left,
+			isOverElement = (y1 + dyClick) > t && (y1 + dyClick) < b && (x1 + dxClick) > l && (x1 + dxClick) < r;
+
+		if ( this.options.tolerance === "pointer" ||
+			this.options.forcePointerForContainers ||
+			(this.options.tolerance !== "pointer" && this.helperProportions[this.floating ? "width" : "height"] > item[this.floating ? "width" : "height"])
+		) {
+			return isOverElement;
+		} else {
+
+			return (l < x1 + (this.helperProportions.width / 2) && // Right Half
+				x2 - (this.helperProportions.width / 2) < r && // Left Half
+				t < y1 + (this.helperProportions.height / 2) && // Bottom Half
+				y2 - (this.helperProportions.height / 2) < b ); // Top Half
+
+		}
+	},
+
+	_intersectsWithPointer: function(item) {
+
+		var isOverElementHeight = (this.options.axis === "x") || isOverAxis(this.positionAbs.top + this.offset.click.top, item.top, item.height),
+			isOverElementWidth = (this.options.axis === "y") || isOverAxis(this.positionAbs.left + this.offset.click.left, item.left, item.width),
+			isOverElement = isOverElementHeight && isOverElementWidth,
+			verticalDirection = this._getDragVerticalDirection(),
+			horizontalDirection = this._getDragHorizontalDirection();
+
+		if (!isOverElement) {
+			return false;
+		}
+
+		return this.floating ?
+			( ((horizontalDirection && horizontalDirection === "right") || verticalDirection === "down") ? 2 : 1 )
+			: ( verticalDirection && (verticalDirection === "down" ? 2 : 1) );
+
+	},
+
+	_intersectsWithSides: function(item) {
+
+		var isOverBottomHalf = isOverAxis(this.positionAbs.top + this.offset.click.top, item.top + (item.height/2), item.height),
+			isOverRightHalf = isOverAxis(this.positionAbs.left + this.offset.click.left, item.left + (item.width/2), item.width),
+			verticalDirection = this._getDragVerticalDirection(),
+			horizontalDirection = this._getDragHorizontalDirection();
+
+		if (this.floating && horizontalDirection) {
+			return ((horizontalDirection === "right" && isOverRightHalf) || (horizontalDirection === "left" && !isOverRightHalf));
+		} else {
+			return verticalDirection && ((verticalDirection === "down" && isOverBottomHalf) || (verticalDirection === "up" && !isOverBottomHalf));
+		}
+
+	},
+
+	_getDragVerticalDirection: function() {
+		var delta = this.positionAbs.top - this.lastPositionAbs.top;
+		return delta !== 0 && (delta > 0 ? "down" : "up");
+	},
+
+	_getDragHorizontalDirection: function() {
+		var delta = this.positionAbs.left - this.lastPositionAbs.left;
+		return delta !== 0 && (delta > 0 ? "right" : "left");
+	},
+
+	refresh: function(event) {
+		this._refreshItems(event);
+		this.refreshPositions();
+		return this;
+	},
+
+	_connectWith: function() {
+		var options = this.options;
+		return options.connectWith.constructor === String ? [options.connectWith] : options.connectWith;
+	},
+
+	_getItemsAsjQuery: function(connected) {
+
+		var i, j, cur, inst,
+			items = [],
+			queries = [],
+			connectWith = this._connectWith();
+
+		if(connectWith && connected) {
+			for (i = connectWith.length - 1; i >= 0; i--){
+				cur = $(connectWith[i]);
+				for ( j = cur.length - 1; j >= 0; j--){
+					inst = $.data(cur[j], this.widgetFullName);
+					if(inst && inst !== this && !inst.options.disabled) {
+						queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element) : $(inst.options.items, inst.element).not(".ui-sortable-helper").not(".ui-sortable-placeholder"), inst]);
+					}
+				}
+			}
+		}
+
+		queries.push([$.isFunction(this.options.items) ? this.options.items.call(this.element, null, { options: this.options, item: this.currentItem }) : $(this.options.items, this.element).not(".ui-sortable-helper").not(".ui-sortable-placeholder"), this]);
+
+		for (i = queries.length - 1; i >= 0; i--){
+			queries[i][0].each(function() {
+				items.push(this);
+			});
+		}
+
+		return $(items);
+
+	},
+
+	_removeCurrentsFromItems: function() {
+
+		var list = this.currentItem.find(":data(" + this.widgetName + "-item)");
+
+		this.items = $.grep(this.items, function (item) {
+			for (var j=0; j < list.length; j++) {
+				if(list[j] === item.item[0]) {
+					return false;
+				}
+			}
+			return true;
+		});
+
+	},
+
+	_refreshItems: function(event) {
+
+		this.items = [];
+		this.containers = [this];
+
+		var i, j, cur, inst, targetData, _queries, item, queriesLength,
+			items = this.items,
+			queries = [[$.isFunction(this.options.items) ? this.options.items.call(this.element[0], event, { item: this.currentItem }) : $(this.options.items, this.element), this]],
+			connectWith = this._connectWith();
+
+		if(connectWith && this.ready) { //Shouldn't be run the first time through due to massive slow-down
+			for (i = connectWith.length - 1; i >= 0; i--){
+				cur = $(connectWith[i]);
+				for (j = cur.length - 1; j >= 0; j--){
+					inst = $.data(cur[j], this.widgetFullName);
+					if(inst && inst !== this && !inst.options.disabled) {
+						queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element[0], event, { item: this.currentItem }) : $(inst.options.items, inst.element), inst]);
+						this.containers.push(inst);
+					}
+				}
+			}
+		}
+
+		for (i = queries.length - 1; i >= 0; i--) {
+			targetData = queries[i][1];
+			_queries = queries[i][0];
+
+			for (j=0, queriesLength = _queries.length; j < queriesLength; j++) {
+				item = $(_queries[j]);
+
+				item.data(this.widgetName + "-item", targetData); // Data for target checking (mouse manager)
+
+				items.push({
+					item: item,
+					instance: targetData,
+					width: 0, height: 0,
+					left: 0, top: 0
+				});
+			}
+		}
+
+	},
+
+	refreshPositions: function(fast) {
+
+		//This has to be redone because due to the item being moved out/into the offsetParent, the offsetParent's position will change
+		if(this.offsetParent && this.helper) {
+			this.offset.parent = this._getParentOffset();
+		}
+
+		var i, item, t, p;
+
+		for (i = this.items.length - 1; i >= 0; i--){
+			item = this.items[i];
+
+			//We ignore calculating positions of all connected containers when we're not over them
+			if(item.instance !== this.currentContainer && this.currentContainer && item.item[0] !== this.currentItem[0]) {
+				continue;
+			}
+
+			t = this.options.toleranceElement ? $(this.options.toleranceElement, item.item) : item.item;
+
+			if (!fast) {
+				item.width = t.outerWidth();
+				item.height = t.outerHeight();
+			}
+
+			p = t.offset();
+			item.left = p.left;
+			item.top = p.top;
+		}
+
+		if(this.options.custom && this.options.custom.refreshContainers) {
+			this.options.custom.refreshContainers.call(this);
+		} else {
+			for (i = this.containers.length - 1; i >= 0; i--){
+				p = this.containers[i].element.offset();
+				this.containers[i].containerCache.left = p.left;
+				this.containers[i].containerCache.top = p.top;
+				this.containers[i].containerCache.width	= this.containers[i].element.outerWidth();
+				this.containers[i].containerCache.height = this.containers[i].element.outerHeight();
+			}
+		}
+
+		return this;
+	},
+
+	_createPlaceholder: function(that) {
+		that = that || this;
+		var className,
+			o = that.options;
+
+		if(!o.placeholder || o.placeholder.constructor === String) {
+			className = o.placeholder;
+			o.placeholder = {
+				element: function() {
+
+					var el = $(document.createElement(that.currentItem[0].nodeName))
+						.addClass(className || that.currentItem[0].className+" ui-sortable-placeholder")
+						.removeClass("ui-sortable-helper")[0];
+
+					if(!className) {
+						el.style.visibility = "hidden";
+					}
+
+					return el;
+				},
+				update: function(container, p) {
+
+					// 1. If a className is set as 'placeholder option, we don't force sizes - the class is responsible for that
+					// 2. The option 'forcePlaceholderSize can be enabled to force it even if a class name is specified
+					if(className && !o.forcePlaceholderSize) {
+						return;
+					}
+
+					//If the element doesn't have a actual height by itself (without styles coming from a stylesheet), it receives the inline height from the dragged item
+					if(!p.height()) { p.height(that.currentItem.innerHeight() - parseInt(that.currentItem.css("paddingTop")||0, 10) - parseInt(that.currentItem.css("paddingBottom")||0, 10)); }
+					if(!p.width()) { p.width(that.currentItem.innerWidth() - parseInt(that.currentItem.css("paddingLeft")||0, 10) - parseInt(that.currentItem.css("paddingRight")||0, 10)); }
+				}
+			};
+		}
+
+		//Create the placeholder
+		that.placeholder = $(o.placeholder.element.call(that.element, that.currentItem));
+
+		//Append it after the actual current item
+		that.currentItem.after(that.placeholder);
+
+		//Update the size of the placeholder (TODO: Logic to fuzzy, see line 316/317)
+		o.placeholder.update(that, that.placeholder);
+
+	},
+
+	_contactContainers: function(event) {
+		var i, j, dist, itemWithLeastDistance, posProperty, sizeProperty, base, cur, nearBottom,
+			innermostContainer = null,
+			innermostIndex = null;
+
+		// get innermost container that intersects with item
+		for (i = this.containers.length - 1; i >= 0; i--) {
+
+			// never consider a container that's located within the item itself
+			if($.contains(this.currentItem[0], this.containers[i].element[0])) {
+				continue;
+			}
+
+			if(this._intersectsWith(this.containers[i].containerCache)) {
+
+				// if we've already found a container and it's more "inner" than this, then continue
+				if(innermostContainer && $.contains(this.containers[i].element[0], innermostContainer.element[0])) {
+					continue;
+				}
+
+				innermostContainer = this.containers[i];
+				innermostIndex = i;
+
+			} else {
+				// container doesn't intersect. trigger "out" event if necessary
+				if(this.containers[i].containerCache.over) {
+					this.containers[i]._trigger("out", event, this._uiHash(this));
+					this.containers[i].containerCache.over = 0;
+				}
+			}
+
+		}
+
+		// if no intersecting containers found, return
+		if(!innermostContainer) {
+			return;
+		}
+
+		// move the item into the container if it's not there already
+		if(this.containers.length === 1) {
+			this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
+			this.containers[innermostIndex].containerCache.over = 1;
+		} else {
+
+			//When entering a new container, we will find the item with the least distance and append our item near it
+			dist = 10000;
+			itemWithLeastDistance = null;
+			posProperty = this.containers[innermostIndex].floating ? "left" : "top";
+			sizeProperty = this.containers[innermostIndex].floating ? "width" : "height";
+			base = this.positionAbs[posProperty] + this.offset.click[posProperty];
+			for (j = this.items.length - 1; j >= 0; j--) {
+				if(!$.contains(this.containers[innermostIndex].element[0], this.items[j].item[0])) {
+					continue;
+				}
+				if(this.items[j].item[0] === this.currentItem[0]) {
+					continue;
+				}
+				cur = this.items[j].item.offset()[posProperty];
+				nearBottom = false;
+				if(Math.abs(cur - base) > Math.abs(cur + this.items[j][sizeProperty] - base)){
+					nearBottom = true;
+					cur += this.items[j][sizeProperty];
+				}
+
+				if(Math.abs(cur - base) < dist) {
+					dist = Math.abs(cur - base); itemWithLeastDistance = this.items[j];
+					this.direction = nearBottom ? "up": "down";
+				}
+			}
+
+			//Check if dropOnEmpty is enabled
+			if(!itemWithLeastDistance && !this.options.dropOnEmpty) {
+				return;
+			}
+
+			this.currentContainer = this.containers[innermostIndex];
+			itemWithLeastDistance ? this._rearrange(event, itemWithLeastDistance, null, true) : this._rearrange(event, null, this.containers[innermostIndex].element, true);
+			this._trigger("change", event, this._uiHash());
+			this.containers[innermostIndex]._trigger("change", event, this._uiHash(this));
+
+			//Update the placeholder
+			this.options.placeholder.update(this.currentContainer, this.placeholder);
+
+			this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
+			this.containers[innermostIndex].containerCache.over = 1;
+		}
+
+
+	},
+
+	_createHelper: function(event) {
+
+		var o = this.options,
+			helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event, this.currentItem])) : (o.helper === "clone" ? this.currentItem.clone() : this.currentItem);
+
+		//Add the helper to the DOM if that didn't happen already
+		if(!helper.parents("body").length) {
+			$(o.appendTo !== "parent" ? o.appendTo : this.currentItem[0].parentNode)[0].appendChild(helper[0]);
+		}
+
+		if(helper[0] === this.currentItem[0]) {
+			this._storedCSS = { width: this.currentItem[0].style.width, height: this.currentItem[0].style.height, position: this.currentItem.css("position"), top: this.currentItem.css("top"), left: this.currentItem.css("left") };
+		}
+
+		if(!helper[0].style.width || o.forceHelperSize) {
+			helper.width(this.currentItem.width());
+		}
+		if(!helper[0].style.height || o.forceHelperSize) {
+			helper.height(this.currentItem.height());
+		}
+
+		return helper;
+
+	},
+
+	_adjustOffsetFromHelper: function(obj) {
+		if (typeof obj === "string") {
+			obj = obj.split(" ");
+		}
+		if ($.isArray(obj)) {
+			obj = {left: +obj[0], top: +obj[1] || 0};
+		}
+		if ("left" in obj) {
+			this.offset.click.left = obj.left + this.margins.left;
+		}
+		if ("right" in obj) {
+			this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
+		}
+		if ("top" in obj) {
+			this.offset.click.top = obj.top + this.margins.top;
+		}
+		if ("bottom" in obj) {
+			this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
+		}
+	},
+
+	_getParentOffset: function() {
+
+
+		//Get the offsetParent and cache its position
+		this.offsetParent = this.helper.offsetParent();
+		var po = this.offsetParent.offset();
+
+		// This is a special case where we need to modify a offset calculated on start, since the following happened:
+		// 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
+		// 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
+		//    the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
+		if(this.cssPosition === "absolute" && this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) {
+			po.left += this.scrollParent.scrollLeft();
+			po.top += this.scrollParent.scrollTop();
+		}
+
+		// This needs to be actually done for all browsers, since pageX/pageY includes this information
+		// with an ugly IE fix
+		if( this.offsetParent[0] === document.body || (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() === "html" && $.ui.ie)) {
+			po = { top: 0, left: 0 };
+		}
+
+		return {
+			top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),
+			left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
+		};
+
+	},
+
+	_getRelativeOffset: function() {
+
+		if(this.cssPosition === "relative") {
+			var p = this.currentItem.position();
+			return {
+				top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(),
+				left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft()
+			};
+		} else {
+			return { top: 0, left: 0 };
+		}
+
+	},
+
+	_cacheMargins: function() {
+		this.margins = {
+			left: (parseInt(this.currentItem.css("marginLeft"),10) || 0),
+			top: (parseInt(this.currentItem.css("marginTop"),10) || 0)
+		};
+	},
+
+	_cacheHelperProportions: function() {
+		this.helperProportions = {
+			width: this.helper.outerWidth(),
+			height: this.helper.outerHeight()
+		};
+	},
+
+	_setContainment: function() {
+
+		var ce, co, over,
+			o = this.options;
+		if(o.containment === "parent") {
+			o.containment = this.helper[0].parentNode;
+		}
+		if(o.containment === "document" || o.containment === "window") {
+			this.containment = [
+				0 - this.offset.relative.left - this.offset.parent.left,
+				0 - this.offset.relative.top - this.offset.parent.top,
+				$(o.containment === "document" ? document : window).width() - this.helperProportions.width - this.margins.left,
+				($(o.containment === "document" ? document : window).height() || document.body.parentNode.scrollHeight) - this.helperProportions.height - this.margins.top
+			];
+		}
+
+		if(!(/^(document|window|parent)$/).test(o.containment)) {
+			ce = $(o.containment)[0];
+			co = $(o.containment).offset();
+			over = ($(ce).css("overflow") !== "hidden");
+
+			this.containment = [
+				co.left + (parseInt($(ce).css("borderLeftWidth"),10) || 0) + (parseInt($(ce).css("paddingLeft"),10) || 0) - this.margins.left,
+				co.top + (parseInt($(ce).css("borderTopWidth"),10) || 0) + (parseInt($(ce).css("paddingTop"),10) || 0) - this.margins.top,
+				co.left+(over ? Math.max(ce.scrollWidth,ce.offsetWidth) : ce.offsetWidth) - (parseInt($(ce).css("borderLeftWidth"),10) || 0) - (parseInt($(ce).css("paddingRight"),10) || 0) - this.helperProportions.width - this.margins.left,
+				co.top+(over ? Math.max(ce.scrollHeight,ce.offsetHeight) : ce.offsetHeight) - (parseInt($(ce).css("borderTopWidth"),10) || 0) - (parseInt($(ce).css("paddingBottom"),10) || 0) - this.helperProportions.height - this.margins.top
+			];
+		}
+
+	},
+
+	_convertPositionTo: function(d, pos) {
+
+		if(!pos) {
+			pos = this.position;
+		}
+		var mod = d === "absolute" ? 1 : -1,
+			scroll = this.cssPosition === "absolute" && !(this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent,
+			scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
+
+		return {
+			top: (
+				pos.top	+																// The absolute mouse position
+				this.offset.relative.top * mod +										// Only for relative positioned nodes: Relative offset from element to offset parent
+				this.offset.parent.top * mod -											// The offsetParent's offset without borders (offset + border)
+				( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ) * mod)
+			),
+			left: (
+				pos.left +																// The absolute mouse position
+				this.offset.relative.left * mod +										// Only for relative positioned nodes: Relative offset from element to offset parent
+				this.offset.parent.left * mod	-										// The offsetParent's offset without borders (offset + border)
+				( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ) * mod)
+			)
+		};
+
+	},
+
+	_generatePosition: function(event) {
+
+		var top, left,
+			o = this.options,
+			pageX = event.pageX,
+			pageY = event.pageY,
+			scroll = this.cssPosition === "absolute" && !(this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent, scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
+
+		// This is another very weird special case that only happens for relative elements:
+		// 1. If the css position is relative
+		// 2. and the scroll parent is the document or similar to the offset parent
+		// we have to refresh the relative offset during the scroll so there are no jumps
+		if(this.cssPosition === "relative" && !(this.scrollParent[0] !== document && this.scrollParent[0] !== this.offsetParent[0])) {
+			this.offset.relative = this._getRelativeOffset();
+		}
+
+		/*
+		 * - Position constraining -
+		 * Constrain the position to a mix of grid, containment.
+		 */
+
+		if(this.originalPosition) { //If we are not dragging yet, we won't check for options
+
+			if(this.containment) {
+				if(event.pageX - this.offset.click.left < this.containment[0]) {
+					pageX = this.containment[0] + this.offset.click.left;
+				}
+				if(event.pageY - this.offset.click.top < this.containment[1]) {
+					pageY = this.containment[1] + this.offset.click.top;
+				}
+				if(event.pageX - this.offset.click.left > this.containment[2]) {
+					pageX = this.containment[2] + this.offset.click.left;
+				}
+				if(event.pageY - this.offset.click.top > this.containment[3]) {
+					pageY = this.containment[3] + this.offset.click.top;
+				}
+			}
+
+			if(o.grid) {
+				top = this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1];
+				pageY = this.containment ? ( (top - this.offset.click.top >= this.containment[1] && top - this.offset.click.top <= this.containment[3]) ? top : ((top - this.offset.click.top >= this.containment[1]) ? top - o.grid[1] : top + o.grid[1])) : top;
+
+				left = this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0];
+				pageX = this.containment ? ( (left - this.offset.click.left >= this.containment[0] && left - this.offset.click.left <= this.containment[2]) ? left : ((left - this.offset.click.left >= this.containment[0]) ? left - o.grid[0] : left + o.grid[0])) : left;
+			}
+
+		}
+
+		return {
+			top: (
+				pageY -																// The absolute mouse position
+				this.offset.click.top -													// Click offset (relative to the element)
+				this.offset.relative.top	-											// Only for relative positioned nodes: Relative offset from element to offset parent
+				this.offset.parent.top +												// The offsetParent's offset without borders (offset + border)
+				( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ))
+			),
+			left: (
+				pageX -																// The absolute mouse position
+				this.offset.click.left -												// Click offset (relative to the element)
+				this.offset.relative.left	-											// Only for relative positioned nodes: Relative offset from element to offset parent
+				this.offset.parent.left +												// The offsetParent's offset without borders (offset + border)
+				( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ))
+			)
+		};
+
+	},
+
+	_rearrange: function(event, i, a, hardRefresh) {
+
+		a ? a[0].appendChild(this.placeholder[0]) : i.item[0].parentNode.insertBefore(this.placeholder[0], (this.direction === "down" ? i.item[0] : i.item[0].nextSibling));
+
+		//Various things done here to improve the performance:
+		// 1. we create a setTimeout, that calls refreshPositions
+		// 2. on the instance, we have a counter variable, that get's higher after every append
+		// 3. on the local scope, we copy the counter variable, and check in the timeout, if it's still the same
+		// 4. this lets only the last addition to the timeout stack through
+		this.counter = this.counter ? ++this.counter : 1;
+		var counter = this.counter;
+
+		this._delay(function() {
+			if(counter === this.counter) {
+				this.refreshPositions(!hardRefresh); //Precompute after each DOM insertion, NOT on mousemove
+			}
+		});
+
+	},
+
+	_clear: function(event, noPropagation) {
+
+		this.reverting = false;
+		// We delay all events that have to be triggered to after the point where the placeholder has been removed and
+		// everything else normalized again
+		var i,
+			delayedTriggers = [];
+
+		// We first have to update the dom position of the actual currentItem
+		// Note: don't do it if the current item is already removed (by a user), or it gets reappended (see #4088)
+		if(!this._noFinalSort && this.currentItem.parent().length) {
+			this.placeholder.before(this.currentItem);
+		}
+		this._noFinalSort = null;
+
+		if(this.helper[0] === this.currentItem[0]) {
+			for(i in this._storedCSS) {
+				if(this._storedCSS[i] === "auto" || this._storedCSS[i] === "static") {
+					this._storedCSS[i] = "";
+				}
+			}
+			this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
+		} else {
+			this.currentItem.show();
+		}
+
+		if(this.fromOutside && !noPropagation) {
+			delayedTriggers.push(function(event) { this._trigger("receive", event, this._uiHash(this.fromOutside)); });
+		}
+		if((this.fromOutside || this.domPosition.prev !== this.currentItem.prev().not(".ui-sortable-helper")[0] || this.domPosition.parent !== this.currentItem.parent()[0]) && !noPropagation) {
+			delayedTriggers.push(function(event) { this._trigger("update", event, this._uiHash()); }); //Trigger update callback if the DOM position has changed
+		}
+
+		// Check if the items Container has Changed and trigger appropriate
+		// events.
+		if (this !== this.currentContainer) {
+			if(!noPropagation) {
+				delayedTriggers.push(function(event) { this._trigger("remove", event, this._uiHash()); });
+				delayedTriggers.push((function(c) { return function(event) { c._trigger("receive", event, this._uiHash(this)); };  }).call(this, this.currentContainer));
+				delayedTriggers.push((function(c) { return function(event) { c._trigger("update", event, this._uiHash(this));  }; }).call(this, this.currentContainer));
+			}
+		}
+
+
+		//Post events to containers
+		for (i = this.containers.length - 1; i >= 0; i--){
+			if(!noPropagation) {
+				delayedTriggers.push((function(c) { return function(event) { c._trigger("deactivate", event, this._uiHash(this)); };  }).call(this, this.containers[i]));
+			}
+			if(this.containers[i].containerCache.over) {
+				delayedTriggers.push((function(c) { return function(event) { c._trigger("out", event, this._uiHash(this)); };  }).call(this, this.containers[i]));
+				this.containers[i].containerCache.over = 0;
+			}
+		}
+
+		//Do what was originally in plugins
+		if(this._storedCursor) {
+			$("body").css("cursor", this._storedCursor);
+		}
+		if(this._storedOpacity) {
+			this.helper.css("opacity", this._storedOpacity);
+		}
+		if(this._storedZIndex) {
+			this.helper.css("zIndex", this._storedZIndex === "auto" ? "" : this._storedZIndex);
+		}
+
+		this.dragging = false;
+		if(this.cancelHelperRemoval) {
+			if(!noPropagation) {
+				this._trigger("beforeStop", event, this._uiHash());
+				for (i=0; i < delayedTriggers.length; i++) {
+					delayedTriggers[i].call(this, event);
+				} //Trigger all delayed events
+				this._trigger("stop", event, this._uiHash());
+			}
+
+			this.fromOutside = false;
+			return false;
+		}
+
+		if(!noPropagation) {
+			this._trigger("beforeStop", event, this._uiHash());
+		}
+
+		//$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
+		this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
+
+		if(this.helper[0] !== this.currentItem[0]) {
+			this.helper.remove();
+		}
+		this.helper = null;
+
+		if(!noPropagation) {
+			for (i=0; i < delayedTriggers.length; i++) {
+				delayedTriggers[i].call(this, event);
+			} //Trigger all delayed events
+			this._trigger("stop", event, this._uiHash());
+		}
+
+		this.fromOutside = false;
+		return true;
+
+	},
+
+	_trigger: function() {
+		if ($.Widget.prototype._trigger.apply(this, arguments) === false) {
+			this.cancel();
+		}
+	},
+
+	_uiHash: function(_inst) {
+		var inst = _inst || this;
+		return {
+			helper: inst.helper,
+			placeholder: inst.placeholder || $([]),
+			position: inst.position,
+			originalPosition: inst.originalPosition,
+			offset: inst.positionAbs,
+			item: inst.currentItem,
+			sender: _inst ? _inst.element : null
+		};
+	}
+
+});
+
+})(jQuery);
+
+});
\ No newline at end of file
diff --git a/module/web/static/js/libs/jqueryui/widget.js b/module/web/static/js/libs/jqueryui/widget.js
new file mode 100644
index 000000000..f139afb58
--- /dev/null
+++ b/module/web/static/js/libs/jqueryui/widget.js
@@ -0,0 +1,524 @@
+define(['jquery'], function (jQuery) {
+/*!
+ * jQuery UI Widget 1.10.1
+ * http://jqueryui.com
+ *
+ * Copyright 2013 jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ *
+ * http://api.jqueryui.com/jQuery.widget/
+ */
+(function( $, undefined ) {
+
+var uuid = 0,
+	slice = Array.prototype.slice,
+	_cleanData = $.cleanData;
+$.cleanData = function( elems ) {
+	for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
+		try {
+			$( elem ).triggerHandler( "remove" );
+		// http://bugs.jquery.com/ticket/8235
+		} catch( e ) {}
+	}
+	_cleanData( elems );
+};
+
+$.widget = function( name, base, prototype ) {
+	var fullName, existingConstructor, constructor, basePrototype,
+		// proxiedPrototype allows the provided prototype to remain unmodified
+		// so that it can be used as a mixin for multiple widgets (#8876)
+		proxiedPrototype = {},
+		namespace = name.split( "." )[ 0 ];
+
+	name = name.split( "." )[ 1 ];
+	fullName = namespace + "-" + name;
+
+	if ( !prototype ) {
+		prototype = base;
+		base = $.Widget;
+	}
+
+	// create selector for plugin
+	$.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {
+		return !!$.data( elem, fullName );
+	};
+
+	$[ namespace ] = $[ namespace ] || {};
+	existingConstructor = $[ namespace ][ name ];
+	constructor = $[ namespace ][ name ] = function( options, element ) {
+		// allow instantiation without "new" keyword
+		if ( !this._createWidget ) {
+			return new constructor( options, element );
+		}
+
+		// allow instantiation without initializing for simple inheritance
+		// must use "new" keyword (the code above always passes args)
+		if ( arguments.length ) {
+			this._createWidget( options, element );
+		}
+	};
+	// extend with the existing constructor to carry over any static properties
+	$.extend( constructor, existingConstructor, {
+		version: prototype.version,
+		// copy the object used to create the prototype in case we need to
+		// redefine the widget later
+		_proto: $.extend( {}, prototype ),
+		// track widgets that inherit from this widget in case this widget is
+		// redefined after a widget inherits from it
+		_childConstructors: []
+	});
+
+	basePrototype = new base();
+	// we need to make the options hash a property directly on the new instance
+	// otherwise we'll modify the options hash on the prototype that we're
+	// inheriting from
+	basePrototype.options = $.widget.extend( {}, basePrototype.options );
+	$.each( prototype, function( prop, value ) {
+		if ( !$.isFunction( value ) ) {
+			proxiedPrototype[ prop ] = value;
+			return;
+		}
+		proxiedPrototype[ prop ] = (function() {
+			var _super = function() {
+					return base.prototype[ prop ].apply( this, arguments );
+				},
+				_superApply = function( args ) {
+					return base.prototype[ prop ].apply( this, args );
+				};
+			return function() {
+				var __super = this._super,
+					__superApply = this._superApply,
+					returnValue;
+
+				this._super = _super;
+				this._superApply = _superApply;
+
+				returnValue = value.apply( this, arguments );
+
+				this._super = __super;
+				this._superApply = __superApply;
+
+				return returnValue;
+			};
+		})();
+	});
+	constructor.prototype = $.widget.extend( basePrototype, {
+		// TODO: remove support for widgetEventPrefix
+		// always use the name + a colon as the prefix, e.g., draggable:start
+		// don't prefix for widgets that aren't DOM-based
+		widgetEventPrefix: existingConstructor ? basePrototype.widgetEventPrefix : name
+	}, proxiedPrototype, {
+		constructor: constructor,
+		namespace: namespace,
+		widgetName: name,
+		widgetFullName: fullName
+	});
+
+	// If this widget is being redefined then we need to find all widgets that
+	// are inheriting from it and redefine all of them so that they inherit from
+	// the new version of this widget. We're essentially trying to replace one
+	// level in the prototype chain.
+	if ( existingConstructor ) {
+		$.each( existingConstructor._childConstructors, function( i, child ) {
+			var childPrototype = child.prototype;
+
+			// redefine the child widget using the same prototype that was
+			// originally used, but inherit from the new version of the base
+			$.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto );
+		});
+		// remove the list of existing child constructors from the old constructor
+		// so the old child constructors can be garbage collected
+		delete existingConstructor._childConstructors;
+	} else {
+		base._childConstructors.push( constructor );
+	}
+
+	$.widget.bridge( name, constructor );
+};
+
+$.widget.extend = function( target ) {
+	var input = slice.call( arguments, 1 ),
+		inputIndex = 0,
+		inputLength = input.length,
+		key,
+		value;
+	for ( ; inputIndex < inputLength; inputIndex++ ) {
+		for ( key in input[ inputIndex ] ) {
+			value = input[ inputIndex ][ key ];
+			if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {
+				// Clone objects
+				if ( $.isPlainObject( value ) ) {
+					target[ key ] = $.isPlainObject( target[ key ] ) ?
+						$.widget.extend( {}, target[ key ], value ) :
+						// Don't extend strings, arrays, etc. with objects
+						$.widget.extend( {}, value );
+				// Copy everything else by reference
+				} else {
+					target[ key ] = value;
+				}
+			}
+		}
+	}
+	return target;
+};
+
+$.widget.bridge = function( name, object ) {
+	var fullName = object.prototype.widgetFullName || name;
+	$.fn[ name ] = function( options ) {
+		var isMethodCall = typeof options === "string",
+			args = slice.call( arguments, 1 ),
+			returnValue = this;
+
+		// allow multiple hashes to be passed on init
+		options = !isMethodCall && args.length ?
+			$.widget.extend.apply( null, [ options ].concat(args) ) :
+			options;
+
+		if ( isMethodCall ) {
+			this.each(function() {
+				var methodValue,
+					instance = $.data( this, fullName );
+				if ( !instance ) {
+					return $.error( "cannot call methods on " + name + " prior to initialization; " +
+						"attempted to call method '" + options + "'" );
+				}
+				if ( !$.isFunction( instance[options] ) || options.charAt( 0 ) === "_" ) {
+					return $.error( "no such method '" + options + "' for " + name + " widget instance" );
+				}
+				methodValue = instance[ options ].apply( instance, args );
+				if ( methodValue !== instance && methodValue !== undefined ) {
+					returnValue = methodValue && methodValue.jquery ?
+						returnValue.pushStack( methodValue.get() ) :
+						methodValue;
+					return false;
+				}
+			});
+		} else {
+			this.each(function() {
+				var instance = $.data( this, fullName );
+				if ( instance ) {
+					instance.option( options || {} )._init();
+				} else {
+					$.data( this, fullName, new object( options, this ) );
+				}
+			});
+		}
+
+		return returnValue;
+	};
+};
+
+$.Widget = function( /* options, element */ ) {};
+$.Widget._childConstructors = [];
+
+$.Widget.prototype = {
+	widgetName: "widget",
+	widgetEventPrefix: "",
+	defaultElement: "<div>",
+	options: {
+		disabled: false,
+
+		// callbacks
+		create: null
+	},
+	_createWidget: function( options, element ) {
+		element = $( element || this.defaultElement || this )[ 0 ];
+		this.element = $( element );
+		this.uuid = uuid++;
+		this.eventNamespace = "." + this.widgetName + this.uuid;
+		this.options = $.widget.extend( {},
+			this.options,
+			this._getCreateOptions(),
+			options );
+
+		this.bindings = $();
+		this.hoverable = $();
+		this.focusable = $();
+
+		if ( element !== this ) {
+			$.data( element, this.widgetFullName, this );
+			this._on( true, this.element, {
+				remove: function( event ) {
+					if ( event.target === element ) {
+						this.destroy();
+					}
+				}
+			});
+			this.document = $( element.style ?
+				// element within the document
+				element.ownerDocument :
+				// element is window or document
+				element.document || element );
+			this.window = $( this.document[0].defaultView || this.document[0].parentWindow );
+		}
+
+		this._create();
+		this._trigger( "create", null, this._getCreateEventData() );
+		this._init();
+	},
+	_getCreateOptions: $.noop,
+	_getCreateEventData: $.noop,
+	_create: $.noop,
+	_init: $.noop,
+
+	destroy: function() {
+		this._destroy();
+		// we can probably remove the unbind calls in 2.0
+		// all event bindings should go through this._on()
+		this.element
+			.unbind( this.eventNamespace )
+			// 1.9 BC for #7810
+			// TODO remove dual storage
+			.removeData( this.widgetName )
+			.removeData( this.widgetFullName )
+			// support: jquery <1.6.3
+			// http://bugs.jquery.com/ticket/9413
+			.removeData( $.camelCase( this.widgetFullName ) );
+		this.widget()
+			.unbind( this.eventNamespace )
+			.removeAttr( "aria-disabled" )
+			.removeClass(
+				this.widgetFullName + "-disabled " +
+				"ui-state-disabled" );
+
+		// clean up events and states
+		this.bindings.unbind( this.eventNamespace );
+		this.hoverable.removeClass( "ui-state-hover" );
+		this.focusable.removeClass( "ui-state-focus" );
+	},
+	_destroy: $.noop,
+
+	widget: function() {
+		return this.element;
+	},
+
+	option: function( key, value ) {
+		var options = key,
+			parts,
+			curOption,
+			i;
+
+		if ( arguments.length === 0 ) {
+			// don't return a reference to the internal hash
+			return $.widget.extend( {}, this.options );
+		}
+
+		if ( typeof key === "string" ) {
+			// handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
+			options = {};
+			parts = key.split( "." );
+			key = parts.shift();
+			if ( parts.length ) {
+				curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
+				for ( i = 0; i < parts.length - 1; i++ ) {
+					curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
+					curOption = curOption[ parts[ i ] ];
+				}
+				key = parts.pop();
+				if ( value === undefined ) {
+					return curOption[ key ] === undefined ? null : curOption[ key ];
+				}
+				curOption[ key ] = value;
+			} else {
+				if ( value === undefined ) {
+					return this.options[ key ] === undefined ? null : this.options[ key ];
+				}
+				options[ key ] = value;
+			}
+		}
+
+		this._setOptions( options );
+
+		return this;
+	},
+	_setOptions: function( options ) {
+		var key;
+
+		for ( key in options ) {
+			this._setOption( key, options[ key ] );
+		}
+
+		return this;
+	},
+	_setOption: function( key, value ) {
+		this.options[ key ] = value;
+
+		if ( key === "disabled" ) {
+			this.widget()
+				.toggleClass( this.widgetFullName + "-disabled ui-state-disabled", !!value )
+				.attr( "aria-disabled", value );
+			this.hoverable.removeClass( "ui-state-hover" );
+			this.focusable.removeClass( "ui-state-focus" );
+		}
+
+		return this;
+	},
+
+	enable: function() {
+		return this._setOption( "disabled", false );
+	},
+	disable: function() {
+		return this._setOption( "disabled", true );
+	},
+
+	_on: function( suppressDisabledCheck, element, handlers ) {
+		var delegateElement,
+			instance = this;
+
+		// no suppressDisabledCheck flag, shuffle arguments
+		if ( typeof suppressDisabledCheck !== "boolean" ) {
+			handlers = element;
+			element = suppressDisabledCheck;
+			suppressDisabledCheck = false;
+		}
+
+		// no element argument, shuffle and use this.element
+		if ( !handlers ) {
+			handlers = element;
+			element = this.element;
+			delegateElement = this.widget();
+		} else {
+			// accept selectors, DOM elements
+			element = delegateElement = $( element );
+			this.bindings = this.bindings.add( element );
+		}
+
+		$.each( handlers, function( event, handler ) {
+			function handlerProxy() {
+				// allow widgets to customize the disabled handling
+				// - disabled as an array instead of boolean
+				// - disabled class as method for disabling individual parts
+				if ( !suppressDisabledCheck &&
+						( instance.options.disabled === true ||
+							$( this ).hasClass( "ui-state-disabled" ) ) ) {
+					return;
+				}
+				return ( typeof handler === "string" ? instance[ handler ] : handler )
+					.apply( instance, arguments );
+			}
+
+			// copy the guid so direct unbinding works
+			if ( typeof handler !== "string" ) {
+				handlerProxy.guid = handler.guid =
+					handler.guid || handlerProxy.guid || $.guid++;
+			}
+
+			var match = event.match( /^(\w+)\s*(.*)$/ ),
+				eventName = match[1] + instance.eventNamespace,
+				selector = match[2];
+			if ( selector ) {
+				delegateElement.delegate( selector, eventName, handlerProxy );
+			} else {
+				element.bind( eventName, handlerProxy );
+			}
+		});
+	},
+
+	_off: function( element, eventName ) {
+		eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) + this.eventNamespace;
+		element.unbind( eventName ).undelegate( eventName );
+	},
+
+	_delay: function( handler, delay ) {
+		function handlerProxy() {
+			return ( typeof handler === "string" ? instance[ handler ] : handler )
+				.apply( instance, arguments );
+		}
+		var instance = this;
+		return setTimeout( handlerProxy, delay || 0 );
+	},
+
+	_hoverable: function( element ) {
+		this.hoverable = this.hoverable.add( element );
+		this._on( element, {
+			mouseenter: function( event ) {
+				$( event.currentTarget ).addClass( "ui-state-hover" );
+			},
+			mouseleave: function( event ) {
+				$( event.currentTarget ).removeClass( "ui-state-hover" );
+			}
+		});
+	},
+
+	_focusable: function( element ) {
+		this.focusable = this.focusable.add( element );
+		this._on( element, {
+			focusin: function( event ) {
+				$( event.currentTarget ).addClass( "ui-state-focus" );
+			},
+			focusout: function( event ) {
+				$( event.currentTarget ).removeClass( "ui-state-focus" );
+			}
+		});
+	},
+
+	_trigger: function( type, event, data ) {
+		var prop, orig,
+			callback = this.options[ type ];
+
+		data = data || {};
+		event = $.Event( event );
+		event.type = ( type === this.widgetEventPrefix ?
+			type :
+			this.widgetEventPrefix + type ).toLowerCase();
+		// the original event may come from any element
+		// so we need to reset the target on the new event
+		event.target = this.element[ 0 ];
+
+		// copy original event properties over to the new event
+		orig = event.originalEvent;
+		if ( orig ) {
+			for ( prop in orig ) {
+				if ( !( prop in event ) ) {
+					event[ prop ] = orig[ prop ];
+				}
+			}
+		}
+
+		this.element.trigger( event, data );
+		return !( $.isFunction( callback ) &&
+			callback.apply( this.element[0], [ event ].concat( data ) ) === false ||
+			event.isDefaultPrevented() );
+	}
+};
+
+$.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
+	$.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
+		if ( typeof options === "string" ) {
+			options = { effect: options };
+		}
+		var hasOptions,
+			effectName = !options ?
+				method :
+				options === true || typeof options === "number" ?
+					defaultEffect :
+					options.effect || defaultEffect;
+		options = options || {};
+		if ( typeof options === "number" ) {
+			options = { duration: options };
+		}
+		hasOptions = !$.isEmptyObject( options );
+		options.complete = callback;
+		if ( options.delay ) {
+			element.delay( options.delay );
+		}
+		if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
+			element[ method ]( options );
+		} else if ( effectName !== method && element[ effectName ] ) {
+			element[ effectName ]( options.duration, options.easing, callback );
+		} else {
+			element.queue(function( next ) {
+				$( this )[ method ]();
+				if ( callback ) {
+					callback.call( element[ 0 ] );
+				}
+				next();
+			});
+		}
+	};
+});
+
+})( jQuery );
+
+});
\ No newline at end of file
diff --git a/module/web/static/js/libs/less-1.3.0.min.js b/module/web/static/js/libs/less-1.3.0.min.js
new file mode 100644
index 000000000..309bf550d
--- /dev/null
+++ b/module/web/static/js/libs/less-1.3.0.min.js
@@ -0,0 +1,9 @@
+//
+// LESS - Leaner CSS v1.3.0
+// http://lesscss.org
+// 
+// Copyright (c) 2009-2011, Alexis Sellier
+// Licensed under the Apache 2.0 License.
+//
+(function(a,b){function c(b){return a.less[b.split("/")[1]]}function l(){var a=document.getElementsByTagName("style");for(var b=0;b<a.length;b++)a[b].type.match(j)&&(new d.Parser).parse(a[b].innerHTML||"",function(c,d){var e=d.toCSS(),f=a[b];f.type="text/css",f.styleSheet?f.styleSheet.cssText=e:f.innerHTML=e})}function m(a,b){for(var c=0;c<d.sheets.length;c++)n(d.sheets[c],a,b,d.sheets.length-(c+1))}function n(b,c,e,f){var h=a.location.href.replace(/[#?].*$/,""),i=b.href.replace(/\?.*$/,""),j=g&&g.getItem(i),k=g&&g.getItem(i+":timestamp"),l={css:j,timestamp:k};/^(https?|file):/.test(i)||(i.charAt(0)=="/"?i=a.location.protocol+"//"+a.location.host+i:i=h.slice(0,h.lastIndexOf("/")+1)+i);var m=i.match(/([^\/]+)$/)[1];q(b.href,b.type,function(a,g){if(!e&&l&&g&&(new Date(g)).valueOf()===(new Date(l.timestamp)).valueOf())p(l.css,b),c(null,null,a,b,{local:!0,remaining:f});else try{(new d.Parser({optimization:d.optimization,paths:[i.replace(/[\w\.-]+$/,"")],mime:b.type,filename:m})).parse(a,function(d,e){if(d)return u(d,i);try{c(d,e,a,b,{local:!1,lastModified:g,remaining:f}),s(document.getElementById("less-error-message:"+o(i)))}catch(d){u(d,i)}})}catch(h){u(h,i)}},function(a,b){throw new Error("Couldn't load "+b+" ("+a+")")})}function o(a){return a.replace(/^[a-z]+:\/\/?[^\/]+/,"").replace(/^\//,"").replace(/\?.*$/,"").replace(/\.[^\.\/]+$/,"").replace(/[^\.\w-]+/g,"-").replace(/\./g,":")}function p(a,b,c){var d,e=b.href?b.href.replace(/\?.*$/,""):"",f="less:"+(b.title||o(e));(d=document.getElementById(f))===null&&(d=document.createElement("style"),d.type="text/css",d.media=b.media||"screen",d.id=f,document.getElementsByTagName("head")[0].appendChild(d));if(d.styleSheet)try{d.styleSheet.cssText=a}catch(h){throw new Error("Couldn't reassign styleSheet.cssText.")}else(function(a){d.childNodes.length>0?d.firstChild.nodeValue!==a.nodeValue&&d.replaceChild(a,d.firstChild):d.appendChild(a)})(document.createTextNode(a));c&&g&&(t("saving "+e+" to cache."),g.setItem(e,a),g.setItem(e+":timestamp",c))}function q(a,b,c,e){function i(b,c,d){b.status>=200&&b.status<300?c(b.responseText,b.getResponseHeader("Last-Modified")):typeof d=="function"&&d(b.status,a)}var g=r(),h=f?!1:d.async;typeof g.overrideMimeType=="function"&&g.overrideMimeType("text/css"),g.open("GET",a,h),g.setRequestHeader("Accept",b||"text/x-less, text/css; q=0.9, */*; q=0.5"),g.send(null),f?g.status===0||g.status>=200&&g.status<300?c(g.responseText):e(g.status,a):h?g.onreadystatechange=function(){g.readyState==4&&i(g,c,e)}:i(g,c,e)}function r(){if(a.XMLHttpRequest)return new XMLHttpRequest;try{return new ActiveXObject("MSXML2.XMLHTTP.3.0")}catch(b){return t("browser doesn't support AJAX."),null}}function s(a){return a&&a.parentNode.removeChild(a)}function t(a){d.env=="development"&&typeof console!="undefined"&&console.log("less: "+a)}function u(a,b){var c="less-error-message:"+o(b),e='<li><label>{line}</label><pre class="{class}">{content}</pre></li>',f=document.createElement("div"),g,h,i=[],j=a.filename||b;f.id=c,f.className="less-error-message",h="<h3>"+(a.message||"There is an error in your .less file")+"</h3>"+'<p>in <a href="'+j+'">'+j+"</a> ";var k=function(a,b,c){a.extract[b]&&i.push(e.replace(/\{line\}/,parseInt(a.line)+(b-1)).replace(/\{class\}/,c).replace(/\{content\}/,a.extract[b]))};a.stack?h+="<br/>"+a.stack.split("\n").slice(1).join("<br/>"):a.extract&&(k(a,0,""),k(a,1,"line"),k(a,2,""),h+="on line "+a.line+", column "+(a.column+1)+":</p>"+"<ul>"+i.join("")+"</ul>"),f.innerHTML=h,p([".less-error-message ul, .less-error-message li {","list-style-type: none;","margin-right: 15px;","padding: 4px 0;","margin: 0;","}",".less-error-message label {","font-size: 12px;","margin-right: 15px;","padding: 4px 0;","color: #cc7777;","}",".less-error-message pre {","color: #dd6666;","padding: 4px 0;","margin: 0;","display: inline-block;","}",".less-error-message pre.line {","color: #ff0000;","}",".less-error-message h3 {","font-size: 20px;","font-weight: bold;","padding: 15px 0 5px 0;","margin: 0;","}",".less-error-message a {","color: #10a","}",".less-error-message .error {","color: red;","font-weight: bold;","padding-bottom: 2px;","border-bottom: 1px dashed red;","}"].join("\n"),{title:"error-message"}),f.style.cssText=["font-family: Arial, sans-serif","border: 1px solid #e00","background-color: #eee","border-radius: 5px","-webkit-border-radius: 5px","-moz-border-radius: 5px","color: #e00","padding: 15px","margin-bottom: 15px"].join(";"),d.env=="development"&&(g=setInterval(function(){document.body&&(document.getElementById(c)?document.body.replaceChild(f,document.getElementById(c)):document.body.insertBefore(f,document.body.firstChild),clearInterval(g))},10))}typeof define=="function"&&define.amd&&define("less",[],function(){return d}),Array.isArray||(Array.isArray=function(a){return Object.prototype.toString.call(a)==="[object Array]"||a instanceof Array}),Array.prototype.forEach||(Array.prototype.forEach=function(a,b){var c=this.length>>>0;for(var d=0;d<c;d++)d in this&&a.call(b,this[d],d,this)}),Array.prototype.map||(Array.prototype.map=function(a){var b=this.length>>>0,c=new Array(b),d=arguments[1];for(var e=0;e<b;e++)e in this&&(c[e]=a.call(d,this[e],e,this));return c}),Array.prototype.filter||(Array.prototype.filter=function(a){var b=[],c=arguments[1];for(var d=0;d<this.length;d++)a.call(c,this[d])&&b.push(this[d]);return b}),Array.prototype.reduce||(Array.prototype.reduce=function(a){var b=this.length>>>0,c=0;if(b===0&&arguments.length===1)throw new TypeError;if(arguments.length>=2)var d=arguments[1];else do{if(c in this){d=this[c++];break}if(++c>=b)throw new TypeError}while(!0);for(;c<b;c++)c in this&&(d=a.call(null,d,this[c],c,this));return d}),Array.prototype.indexOf||(Array.prototype.indexOf=function(a){var b=this.length,c=arguments[1]||0;if(!b)return-1;if(c>=b)return-1;c<0&&(c+=b);for(;c<b;c++){if(!Object.prototype.hasOwnProperty.call(this,c))continue;if(a===this[c])return c}return-1}),Object.keys||(Object.keys=function(a){var b=[];for(var c in a)Object.prototype.hasOwnProperty.call(a,c)&&b.push(c);return b}),String.prototype.trim||(String.prototype.trim=function(){return String(this).replace(/^\s\s*/,"").replace(/\s\s*$/,"")});var d,e;typeof environment=="object"&&{}.toString.call(environment)==="[object Environment]"?(typeof a=="undefined"?d={}:d=a.less={},e=d.tree={},d.mode="rhino"):typeof a=="undefined"?(d=exports,e=c("./tree"),d.mode="node"):(typeof a.less=="undefined"&&(a.less={}),d=a.less,e=a.less.tree={},d.mode="browser"),d.Parser=function v(a){function q(){h=k[g],i=f,l=f}function r(){k[g]=h,f=i,l=f}function s(){f>l&&(k[g]=k[g].slice(f-l),l=f)}function t(a){var c,d,e,h,i,j,n,o;if(a instanceof Function)return a.call(m.parsers);if(typeof a=="string")c=b.charAt(f)===a?a:null,e=1,s();else{s();if(c=a.exec(k[g]))e=c[0].length;else return null}if(c){o=f+=e,j=f+k[g].length-e;while(f<j){h=b.charCodeAt(f);if(h!==32&&h!==10&&h!==9)break;f++}return k[g]=k[g].slice(e+(f-o)),l=f,k[g].length===0&&g<k.length-1&&g++,typeof c=="string"?c:c.length===1?c[0]:c}}function u(a,c){var d=t(a);if(!d)v(c||(typeof a=="string"?"expected '"+a+"' got '"+b.charAt(f)+"'":"unexpected token"));else return d}function v(a,b){throw{index:f,type:b||"Syntax",message:a}}function w(a){return typeof a=="string"?b.charAt(f)===a:a.test(k[g])?!0:!1}function x(a){return d.mode==="node"?c("path").basename(a):a.match(/[^\/]+$/)[0]}function y(a,c){return a.filename&&c.filename&&a.filename!==c.filename?m.imports.contents[x(a.filename)]:b}function z(a,b){for(var c=a,d=-1;c>=0&&b.charAt(c)!=="\n";c--)d++;return{line:typeof a=="number"?(b.slice(0,a).match(/\n/g)||"").length:null,column:d}}function A(a,b){var c=y(a,b),d=z(a.index,c),e=d.line,f=d.column,g=c.split("\n");this.type=a.type||"Syntax",this.message=a.message,this.filename=a.filename||b.filename,this.index=a.index,this.line=typeof e=="number"?e+1:null,this.callLine=a.call&&z(a.call,c).line+1,this.callExtract=g[z(a.call,c).line],this.stack=a.stack,this.column=f,this.extract=[g[e-1],g[e],g[e+1]]}var b,f,g,h,i,j,k,l,m,n=this,o=function(){},p=this.imports={paths:a&&a.paths||[],queue:[],files:{},contents:{},mime:a&&a.mime,error:null,push:function(b,c){var e=this;this.queue.push(b),d.Parser.importer(b,this.paths,function(a,d,f){e.queue.splice(e.queue.indexOf(b),1),e.files[b]=d,e.contents[b]=f,a&&!e.error&&(e.error=a),c(a,d),e.queue.length===0&&o()},a)}};return this.env=a=a||{},this.optimization="optimization"in this.env?this.env.optimization:1,this.env.filename=this.env.filename||null,m={imports:p,parse:function(h,i){var n,p,q,r,s,u,v=[],w,x=null;f=g=l=j=0,b=h.replace(/\r\n/g,"\n"),k=function(c){var d=0,e=/[^"'`\{\}\/\(\)\\]+/g,f=/\/\*(?:[^*]|\*+[^\/*])*\*+\/|\/\/.*/g,g=/"((?:[^"\\\r\n]|\\.)*)"|'((?:[^'\\\r\n]|\\.)*)'|`((?:[^`\\\r\n]|\\.)*)`/g,h=0,i,j=c[0],k;for(var l=0,m,n;l<b.length;l++){e.lastIndex=l,(i=e.exec(b))&&i.index===l&&(l+=i[0].length,j.push(i[0])),m=b.charAt(l),f.lastIndex=g.lastIndex=l,(i=g.exec(b))&&i.index===l&&(l+=i[0].length,j.push(i[0]),m=b.charAt(l)),!k&&m==="/"&&(n=b.charAt(l+1),(n==="/"||n==="*")&&(i=f.exec(b))&&i.index===l&&(l+=i[0].length,j.push(i[0]),m=b.charAt(l)));switch(m){case"{":if(!k){h++,j.push(m);break};case"}":if(!k){h--,j.push(m),c[++d]=j=[];break};case"(":if(!k){k=!0,j.push(m);break};case")":if(k){k=!1,j.push(m);break};default:j.push(m)}}return h>0&&(x=new A({index:l,type:"Parse",message:"missing closing `}`",filename:a.filename},a)),c.map(function(a){return a.join("")})}([[]]);if(x)return i(x);try{n=new e.Ruleset([],t(this.parsers.primary)),n.root=!0}catch(y){return i(new A(y,a))}n.toCSS=function(b){var f,g,h;return function(f,g){var h=[],i;f=f||{},typeof g=="object"&&!Array.isArray(g)&&(g=Object.keys(g).map(function(a){var b=g[a];return b instanceof e.Value||(b instanceof e.Expression||(b=new e.Expression([b])),b=new e.Value([b])),new e.Rule("@"+a,b,!1,0)}),h=[new e.Ruleset(null,g)]);try{var j=b.call(this,{frames:h}).toCSS([],{compress:f.compress||!1})}catch(k){throw new A(k,a)}if(i=m.imports.error)throw i instanceof A?i:new A(i,a);return f.yuicompress&&d.mode==="node"?c("./cssmin").compressor.cssmin(j):f.compress?j.replace(/(\s)+/g,"$1"):j}}(n.eval);if(f<b.length-1){f=j,u=b.split("\n"),s=(b.slice(0,f).match(/\n/g)||"").length+1;for(var z=f,B=-1;z>=0&&b.charAt(z)!=="\n";z--)B++;x={type:"Parse",message:"Syntax Error on line "+s,index:f,filename:a.filename,line:s,column:B,extract:[u[s-2],u[s-1],u[s]]}}this.imports.queue.length>0?o=function(){i(x,n)}:i(x,n)},parsers:{primary:function(){var a,b=[];while((a=t(this.mixin.definition)||t(this.rule)||t(this.ruleset)||t(this.mixin.call)||t(this.comment)||t(this.directive))||t(/^[\s\n]+/))a&&b.push(a);return b},comment:function(){var a;if(b.charAt(f)!=="/")return;if(b.charAt(f+1)==="/")return new e.Comment(t(/^\/\/.*/),!0);if(a=t(/^\/\*(?:[^*]|\*+[^\/*])*\*+\/\n?/))return new e.Comment(a)},entities:{quoted:function(){var a,c=f,d;b.charAt(c)==="~"&&(c++,d=!0);if(b.charAt(c)!=='"'&&b.charAt(c)!=="'")return;d&&t("~");if(a=t(/^"((?:[^"\\\r\n]|\\.)*)"|'((?:[^'\\\r\n]|\\.)*)'/))return new e.Quoted(a[0],a[1]||a[2],d)},keyword:function(){var a;if(a=t(/^[_A-Za-z-][_A-Za-z0-9-]*/))return e.colors.hasOwnProperty(a)?new e.Color(e.colors[a].slice(1)):new e.Keyword(a)},call:function(){var b,c,d=f;if(!(b=/^([\w-]+|%|progid:[\w\.]+)\(/.exec(k[g])))return;b=b[1].toLowerCase();if(b==="url")return null;f+=b.length;if(b==="alpha")return t(this.alpha);t("("),c=t(this.entities.arguments);if(!t(")"))return;if(b)return new e.Call(b,c,d,a.filename)},arguments:function(){var a=[],b;while(b=t(this.entities.assignment)||t(this.expression)){a.push(b);if(!t(","))break}return a},literal:function(){return t(this.entities.dimension)||t(this.entities.color)||t(this.entities.quoted)},assignment:function(){var a,b;if((a=t(/^\w+(?=\s?=)/i))&&t("=")&&(b=t(this.entity)))return new e.Assignment(a,b)},url:function(){var a;if(b.charAt(f)!=="u"||!t(/^url\(/))return;return a=t(this.entities.quoted)||t(this.entities.variable)||t(this.entities.dataURI)||t(/^[-\w%@$\/.&=:;#+?~]+/)||"",u(")"),new e.URL(a.value||a.data||a instanceof e.Variable?a:new e.Anonymous(a),p.paths)},dataURI:function(){var a;if(t(/^data:/)){a={},a.mime=t(/^[^\/]+\/[^,;)]+/)||"",a.charset=t(/^;\s*charset=[^,;)]+/)||"",a.base64=t(/^;\s*base64/)||"",a.data=t(/^,\s*[^)]+/);if(a.data)return a}},variable:function(){var c,d=f;if(b.charAt(f)==="@"&&(c=t(/^@@?[\w-]+/)))return new e.Variable(c,d,a.filename)},color:function(){var a;if(b.charAt(f)==="#"&&(a=t(/^#([a-fA-F0-9]{6}|[a-fA-F0-9]{3})/)))return new e.Color(a[1])},dimension:function(){var a,c=b.charCodeAt(f);if(c>57||c<45||c===47)return;if(a=t(/^(-?\d*\.?\d+)(px|%|em|rem|pc|ex|in|deg|s|ms|pt|cm|mm|rad|grad|turn)?/))return new e.Dimension(a[1],a[2])},javascript:function(){var a,c=f,d;b.charAt(c)==="~"&&(c++,d=!0);if(b.charAt(c)!=="`")return;d&&t("~");if(a=t(/^`([^`]*)`/))return new e.JavaScript(a[1],f,d)}},variable:function(){var a;if(b.charAt(f)==="@"&&(a=t(/^(@[\w-]+)\s*:/)))return a[1]},shorthand:function(){var a,b;if(!w(/^[@\w.%-]+\/[@\w.-]+/))return;if((a=t(this.entity))&&t("/")&&(b=t(this.entity)))return new e.Shorthand(a,b)},mixin:{call:function(){var c=[],d,g,h,i=f,j=b.charAt(f),k=!1;if(j!=="."&&j!=="#")return;while(d=t(/^[#.](?:[\w-]|\\(?:[a-fA-F0-9]{1,6} ?|[^a-fA-F0-9]))+/))c.push(new e.Element(g,d,f)),g=t(">");t("(")&&(h=t(this.entities.arguments))&&t(")"),t(this.important)&&(k=!0);if(c.length>0&&(t(";")||w("}")))return new e.mixin.Call(c,h||[],i,a.filename,k)},definition:function(){var a,c=[],d,g,h,i,j,k=!1;if(b.charAt(f)!=="."&&b.charAt(f)!=="#"||w(/^[^{]*(;|})/))return;q();if(d=t(/^([#.](?:[\w-]|\\(?:[a-fA-F0-9]{1,6} ?|[^a-fA-F0-9]))+)\s*\(/)){a=d[1];do{if(b.charAt(f)==="."&&t(/^\.{3}/)){k=!0;break}if(!(h=t(this.entities.variable)||t(this.entities.literal)||t(this.entities.keyword)))break;if(h instanceof e.Variable)if(t(":"))i=u(this.expression,"expected expression"),c.push({name:h.name,value:i});else{if(t(/^\.{3}/)){c.push({name:h.name,variadic:!0}),k=!0;break}c.push({name:h.name})}else c.push({value:h})}while(t(","));u(")"),t(/^when/)&&(j=u(this.conditions,"expected condition")),g=t(this.block);if(g)return new e.mixin.Definition(a,c,g,j,k);r()}}},entity:function(){return t(this.entities.literal)||t(this.entities.variable)||t(this.entities.url)||t(this.entities.call)||t(this.entities.keyword)||t(this.entities.javascript)||t(this.comment)},end:function(){return t(";")||w("}")},alpha:function(){var a;if(!t(/^\(opacity=/i))return;if(a=t(/^\d+/)||t(this.entities.variable))return u(")"),new e.Alpha(a)},element:function(){var a,b,c,d;c=t(this.combinator),a=t(/^(?:\d+\.\d+|\d+)%/)||t(/^(?:[.#]?|:*)(?:[\w-]|\\(?:[a-fA-F0-9]{1,6} ?|[^a-fA-F0-9]))+/)||t("*")||t(this.attribute)||t(/^\([^)@]+\)/),a||t("(")&&(d=t(this.entities.variable))&&t(")")&&(a=new e.Paren(d));if(a)return new e.Element(c,a,f);if(c.value&&c.value.charAt(0)==="&")return new e.Element(c,null,f)},combinator:function(){var a,c=b.charAt(f);if(c===">"||c==="+"||c==="~"){f++;while(b.charAt(f)===" ")f++;return new e.Combinator(c)}if(c==="&"){a="&",f++,b.charAt(f)===" "&&(a="& ");while(b.charAt(f)===" ")f++;return new e.Combinator(a)}return b.charAt(f-1)===" "?new e.Combinator(" "):new e.Combinator(null)},selector:function(){var a,c,d=[],g,h;if(t("("))return a=t(this.entity),u(")"),new e.Selector([new e.Element("",a,f)]);while(c=t(this.element)){g=b.charAt(f),d.push(c);if(g==="{"||g==="}"||g===";"||g===",")break}if(d.length>0)return new e.Selector(d)},tag:function(){return t(/^[a-zA-Z][a-zA-Z-]*[0-9]?/)||t("*")},attribute:function(){var a="",b,c,d;if(!t("["))return;if(b=t(/^[a-zA-Z-]+/)||t(this.entities.quoted))(d=t(/^[|~*$^]?=/))&&(c=t(this.entities.quoted)||t(/^[\w-]+/))?a=[b,d,c.toCSS?c.toCSS():c].join(""):a=b;if(!t("]"))return;if(a)return"["+a+"]"},block:function(){var a;if(t("{")&&(a=t(this.primary))&&t("}"))return a},ruleset:function(){var b=[],c,d,g;q();while(c=t(this.selector)){b.push(c),t(this.comment);if(!t(","))break;t(this.comment)}if(b.length>0&&(d=t(this.block)))return new e.Ruleset(b,d,a.strictImports);j=f,r()},rule:function(){var a,c,d=b.charAt(f),h,l;q();if(d==="."||d==="#"||d==="&")return;if(a=t(this.variable)||t(this.property)){a.charAt(0)!="@"&&(l=/^([^@+\/'"*`(;{}-]*);/.exec(k[g]))?(f+=l[0].length-1,c=new e.Anonymous(l[1])):a==="font"?c=t(this.font):c=t(this.value),h=t(this.important);if(c&&t(this.end))return new e.Rule(a,c,h,i);j=f,r()}},"import":function(){var a,b,c=f;if(t(/^@import\s+/)&&(a=t(this.entities.quoted)||t(this.entities.url))){b=t(this.mediaFeatures);if(t(";"))return new e.Import(a,p,b,c)}},mediaFeature:function(){var a,b,c=[];do if(a=t(this.entities.keyword))c.push(a);else if(t("(")){b=t(this.property),a=t(this.entity);if(!t(")"))return null;if(b&&a)c.push(new e.Paren(new e.Rule(b,a,null,f,!0)));else if(a)c.push(new e.Paren(a));else return null}while(a);if(c.length>0)return new e.Expression(c)},mediaFeatures:function(){var a,b=[];do if(a=t(this.mediaFeature)){b.push(a);if(!t(","))break}else if(a=t(this.entities.variable)){b.push(a);if(!t(","))break}while(a);return b.length>0?b:null},media:function(){var a,b;if(t(/^@media/)){a=t(this.mediaFeatures);if(b=t(this.block))return new e.Media(b,a)}},directive:function(){var a,c,d,g,h,i;if(b.charAt(f)!=="@")return;if(c=t(this["import"])||t(this.media))return c;if(a=t(/^@page|@keyframes/)||t(/^@(?:-webkit-|-moz-|-o-|-ms-)[a-z0-9-]+/)){g=(t(/^[^{]+/)||"").trim();if(d=t(this.block))return new e.Directive(a+" "+g,d)}else if(a=t(/^@[-a-z]+/))if(a==="@font-face"){if(d=t(this.block))return new e.Directive(a,d)}else if((c=t(this.entity))&&t(";"))return new e.Directive(a,c)},font:function(){var a=[],b=[],c,d,f,g;while(g=t(this.shorthand)||t(this.entity))b.push(g);a.push(new e.Expression(b));if(t(","))while(g=t(this.expression)){a.push(g);if(!t(","))break}return new e.Value(a)},value:function(){var a,b=[],c;while(a=t(this.expression)){b.push(a);if(!t(","))break}if(b.length>0)return new e.Value(b)},important:function(){if(b.charAt(f)==="!")return t(/^! *important/)},sub:function(){var a;if(t("(")&&(a=t(this.expression))&&t(")"))return a},multiplication:function(){var a,b,c,d;if(a=t(this.operand)){while(!w(/^\/\*/)&&(c=t("/")||t("*"))&&(b=t(this.operand)))d=new e.Operation(c,[d||a,b]);return d||a}},addition:function(){var a,c,d,g;if(a=t(this.multiplication)){while((d=t(/^[-+]\s+/)||b.charAt(f-1)!=" "&&(t("+")||t("-")))&&(c=t(this.multiplication)))g=new e.Operation(d,[g||a,c]);return g||a}},conditions:function(){var a,b,c=f,d;if(a=t(this.condition)){while(t(",")&&(b=t(this.condition)))d=new e.Condition("or",d||a,b,c);return d||a}},condition:function(){var a,b,c,d,g=f,h=!1;t(/^not/)&&(h=!0),u("(");if(a=t(this.addition)||t(this.entities.keyword)||t(this.entities.quoted))return(d=t(/^(?:>=|=<|[<=>])/))?(b=t(this.addition)||t(this.entities.keyword)||t(this.entities.quoted))?c=new e.Condition(d,a,b,g,h):v("expected expression"):c=new e.Condition("=",a,new e.Keyword("true"),g,h),u(")"),t(/^and/)?new e.Condition("and",c,t(this.condition)):c},operand:function(){var a,c=b.charAt(f+1);b.charAt(f)==="-"&&(c==="@"||c==="(")&&(a=t("-"));var d=t(this.sub)||t(this.entities.dimension)||t(this.entities.color)||t(this.entities.variable)||t(this.entities.call);return a?new e.Operation("*",[new e.Dimension(-1),d]):d},expression:function(){var a,b,c=[],d;while(a=t(this.addition)||t(this.entity))c.push(a);if(c.length>0)return new e.Expression(c)},property:function(){var a;if(a=t(/^(\*?-?[-a-z_0-9]+)\s*:/))return a[1]}}}};if(d.mode==="browser"||d.mode==="rhino")d.Parser.importer=function(a,b,c,d){!/^([a-z]+:)?\//.test(a)&&b.length>0&&(a=b[0]+a),n({href:a,title:a,type:d.mime},function(e){e&&typeof d.errback=="function"?d.errback.call(null,a,b,c,d):c.apply(null,arguments)},!0)};(function(a){function b(b){return a.functions.hsla(b.h,b.s,b.l,b.a)}function c(b){if(b instanceof a.Dimension)return parseFloat(b.unit=="%"?b.value/100:b.value);if(typeof b=="number")return b;throw{error:"RuntimeError",message:"color functions take numbers as parameters"}}function d(a){return Math.min(1,Math.max(0,a))}a.functions={rgb:function(a,b,c){return this.rgba(a,b,c,1)},rgba:function(b,d,e,f){var g=[b,d,e].map(function(a){return c(a)}),f=c(f);return new a.Color(g,f)},hsl:function(a,b,c){return this.hsla(a,b,c,1)},hsla:function(a,b,d,e){function h(a){return a=a<0?a+1:a>1?a-1:a,a*6<1?g+(f-g)*a*6:a*2<1?f:a*3<2?g+(f-g)*(2/3-a)*6:g}a=c(a)%360/360,b=c(b),d=c(d),e=c(e);var f=d<=.5?d*(b+1):d+b-d*b,g=d*2-f;return this.rgba(h(a+1/3)*255,h(a)*255,h(a-1/3)*255,e)},hue:function(b){return new a.Dimension(Math.round(b.toHSL().h))},saturation:function(b){return new a.Dimension(Math.round(b.toHSL().s*100),"%")},lightness:function(b){return new a.Dimension(Math.round(b.toHSL().l*100),"%")},alpha:function(b){return new a.Dimension(b.toHSL().a)},saturate:function(a,c){var e=a.toHSL();return e.s+=c.value/100,e.s=d(e.s),b(e)},desaturate:function(a,c){var e=a.toHSL();return e.s-=c.value/100,e.s=d(e.s),b(e)},lighten:function(a,c){var e=a.toHSL();return e.l+=c.value/100,e.l=d(e.l),b(e)},darken:function(a,c){var e=a.toHSL();return e.l-=c.value/100,e.l=d(e.l),b(e)},fadein:function(a,c){var e=a.toHSL();return e.a+=c.value/100,e.a=d(e.a),b(e)},fadeout:function(a,c){var e=a.toHSL();return e.a-=c.value/100,e.a=d(e.a),b(e)},fade:function(a,c){var e=a.toHSL();return e.a=c.value/100,e.a=d(e.a),b(e)},spin:function(a,c){var d=a.toHSL(),e=(d.h+c.value)%360;return d.h=e<0?360+e:e,b(d)},mix:function(b,c,d){var e=d.value/100,f=e*2-1,g=b.toHSL().a-c.toHSL().a,h=((f*g==-1?f:(f+g)/(1+f*g))+1)/2,i=1-h,j=[b.rgb[0]*h+c.rgb[0]*i,b.rgb[1]*h+c.rgb[1]*i,b.rgb[2]*h+c.rgb[2]*i],k=b.alpha*e+c.alpha*(1-e);return new a.Color(j,k)},greyscale:function(b){return this.desaturate(b,new a.Dimension(100))},e:function(b){return new a.Anonymous(b instanceof a.JavaScript?b.evaluated:b)},escape:function(b){return new a.Anonymous(encodeURI(b.value).replace(/=/g,"%3D").replace(/:/g,"%3A").replace(/#/g,"%23").replace(/;/g,"%3B").replace(/\(/g,"%28").replace(/\)/g,"%29"))},"%":function(b){var c=Array.prototype.slice.call(arguments,1),d=b.value;for(var e=0;e<c.length;e++)d=d.replace(/%[sda]/i,function(a){var b=a.match(/s/i)?c[e].value:c[e].toCSS();return a.match(/[A-Z]$/)?encodeURIComponent(b):b});return d=d.replace(/%%/g,"%"),new a.Quoted('"'+d+'"',d)},round:function(a){return this._math("round",a)},ceil:function(a){return this._math("ceil",a)},floor:function(a){return this._math("floor",a)},_math:function(b,d){if(d instanceof a.Dimension)return new a.Dimension(Math[b](c(d)),d.unit);if(typeof d=="number")return Math[b](d);throw{type:"Argument",message:"argument must be a number"}},argb:function(b){return new a.Anonymous(b.toARGB())},percentage:function(b){return new a.Dimension(b.value*100,"%")},color:function(b){if(b instanceof a.Quoted)return new a.Color(b.value.slice(1));throw{type:"Argument",message:"argument must be a string"}},iscolor:function(b){return this._isa(b,a.Color)},isnumber:function(b){return this._isa(b,a.Dimension)},isstring:function(b){return this._isa(b,a.Quoted)},iskeyword:function(b){return this._isa(b,a.Keyword)},isurl:function(b){return this._isa(b,a.URL)},ispixel:function(b){return b instanceof a.Dimension&&b.unit==="px"?a.True:a.False},ispercentage:function(b){return b instanceof a.Dimension&&b.unit==="%"?a.True:a.False},isem:function(b){return b instanceof a.Dimension&&b.unit==="em"?a.True:a.False},_isa:function(b,c){return b instanceof c?a.True:a.False}}})(c("./tree")),function(a){a.colors={aliceblue:"#f0f8ff",antiquewhite:"#faebd7",aqua:"#00ffff",aquamarine:"#7fffd4",azure:"#f0ffff",beige:"#f5f5dc",bisque:"#ffe4c4",black:"#000000",blanchedalmond:"#ffebcd",blue:"#0000ff",blueviolet:"#8a2be2",brown:"#a52a2a",burlywood:"#deb887",cadetblue:"#5f9ea0",chartreuse:"#7fff00",chocolate:"#d2691e",coral:"#ff7f50",cornflowerblue:"#6495ed",cornsilk:"#fff8dc",crimson:"#dc143c",cyan:"#00ffff",darkblue:"#00008b",darkcyan:"#008b8b",darkgoldenrod:"#b8860b",darkgray:"#a9a9a9",darkgrey:"#a9a9a9",darkgreen:"#006400",darkkhaki:"#bdb76b",darkmagenta:"#8b008b",darkolivegreen:"#556b2f",darkorange:"#ff8c00",darkorchid:"#9932cc",darkred:"#8b0000",darksalmon:"#e9967a",darkseagreen:"#8fbc8f",darkslateblue:"#483d8b",darkslategray:"#2f4f4f",darkslategrey:"#2f4f4f",darkturquoise:"#00ced1",darkviolet:"#9400d3",deeppink:"#ff1493",deepskyblue:"#00bfff",dimgray:"#696969",dimgrey:"#696969",dodgerblue:"#1e90ff",firebrick:"#b22222",floralwhite:"#fffaf0",forestgreen:"#228b22",fuchsia:"#ff00ff",gainsboro:"#dcdcdc",ghostwhite:"#f8f8ff",gold:"#ffd700",goldenrod:"#daa520",gray:"#808080",grey:"#808080",green:"#008000",greenyellow:"#adff2f",honeydew:"#f0fff0",hotpink:"#ff69b4",indianred:"#cd5c5c",indigo:"#4b0082",ivory:"#fffff0",khaki:"#f0e68c",lavender:"#e6e6fa",lavenderblush:"#fff0f5",lawngreen:"#7cfc00",lemonchiffon:"#fffacd",lightblue:"#add8e6",lightcoral:"#f08080",lightcyan:"#e0ffff",lightgoldenrodyellow:"#fafad2",lightgray:"#d3d3d3",lightgrey:"#d3d3d3",lightgreen:"#90ee90",lightpink:"#ffb6c1",lightsalmon:"#ffa07a",lightseagreen:"#20b2aa",lightskyblue:"#87cefa",lightslategray:"#778899",lightslategrey:"#778899",lightsteelblue:"#b0c4de",lightyellow:"#ffffe0",lime:"#00ff00",limegreen:"#32cd32",linen:"#faf0e6",magenta:"#ff00ff",maroon:"#800000",mediumaquamarine:"#66cdaa",mediumblue:"#0000cd",mediumorchid:"#ba55d3",mediumpurple:"#9370d8",mediumseagreen:"#3cb371",mediumslateblue:"#7b68ee",mediumspringgreen:"#00fa9a",mediumturquoise:"#48d1cc",mediumvioletred:"#c71585",midnightblue:"#191970",mintcream:"#f5fffa",mistyrose:"#ffe4e1",moccasin:"#ffe4b5",navajowhite:"#ffdead",navy:"#000080",oldlace:"#fdf5e6",olive:"#808000",olivedrab:"#6b8e23",orange:"#ffa500",orangered:"#ff4500",orchid:"#da70d6",palegoldenrod:"#eee8aa",palegreen:"#98fb98",paleturquoise:"#afeeee",palevioletred:"#d87093",papayawhip:"#ffefd5",peachpuff:"#ffdab9",peru:"#cd853f",pink:"#ffc0cb",plum:"#dda0dd",powderblue:"#b0e0e6",purple:"#800080",red:"#ff0000",rosybrown:"#bc8f8f",royalblue:"#4169e1",saddlebrown:"#8b4513",salmon:"#fa8072",sandybrown:"#f4a460",seagreen:"#2e8b57",seashell:"#fff5ee",sienna:"#a0522d",silver:"#c0c0c0",skyblue:"#87ceeb",slateblue:"#6a5acd",slategray:"#708090",slategrey:"#708090",snow:"#fffafa",springgreen:"#00ff7f",steelblue:"#4682b4",tan:"#d2b48c",teal:"#008080",thistle:"#d8bfd8",tomato:"#ff6347",turquoise:"#40e0d0",violet:"#ee82ee",wheat:"#f5deb3",white:"#ffffff",whitesmoke:"#f5f5f5",yellow:"#ffff00",yellowgreen:"#9acd32"}}(c("./tree")),function(a){a.Alpha=function(a){this.value=a},a.Alpha.prototype={toCSS:function(){return"alpha(opacity="+(this.value.toCSS?this.value.toCSS():this.value)+")"},eval:function(a){return this.value.eval&&(this.value=this.value.eval(a)),this}}}(c("../tree")),function(a){a.Anonymous=function(a){this.value=a.value||a},a.Anonymous.prototype={toCSS:function(){return this.value},eval:function(){return this}}}(c("../tree")),function(a){a.Assignment=function(a,b){this.key=a,this.value=b},a.Assignment.prototype={toCSS:function(){return this.key+"="+(this.value.toCSS?this.value.toCSS():this.value)},eval:function(a){return this.value.eval&&(this.value=this.value.eval(a)),this}}}(c("../tree")),function(a){a.Call=function(a,b,c,d){this.name=a,this.args=b,this.index=c,this.filename=d},a.Call.prototype={eval:function(b){var c=this.args.map(function(a){return a.eval(b)});if(!(this.name in a.functions))return new a.Anonymous(this.name+"("+c.map(function(a){return a.toCSS()}).join(", ")+")");try{return a.functions[this.name].apply(a.functions,c)}catch(d){throw{type:d.type||"Runtime",message:"error evaluating function `"+this.name+"`"+(d.message?": "+d.message:""),index:this.index,filename:this.filename}}},toCSS:function(a){return this.eval(a).toCSS()}}}(c("../tree")),function(a){a.Color=function(a,b){Array.isArray(a)?this.rgb=a:a.length==6?this.rgb=a.match(/.{2}/g).map(function(a){return parseInt(a,16)}):this.rgb=a.split("").map(function(a){return parseInt(a+a,16)}),this.alpha=typeof b=="number"?b:1},a.Color.prototype={eval:function(){return this},toCSS:function(){return this.alpha<1?"rgba("+this.rgb.map(function(a){return Math.round(a)}).concat(this.alpha).join(", ")+")":"#"+this.rgb.map(function(a){return a=Math.round(a),a=(a>255?255:a<0?0:a).toString(16),a.length===1?"0"+a:a}).join("")},operate:function(b,c){var d=[];c instanceof a.Color||(c=c.toColor());for(var e=0;e<3;e++)d[e]=a.operate(b,this.rgb[e],c.rgb[e]);return new a.Color(d,this.alpha+c.alpha)},toHSL:function(){var a=this.rgb[0]/255,b=this.rgb[1]/255,c=this.rgb[2]/255,d=this.alpha,e=Math.max(a,b,c),f=Math.min(a,b,c),g,h,i=(e+f)/2,j=e-f;if(e===f)g=h=0;else{h=i>.5?j/(2-e-f):j/(e+f);switch(e){case a:g=(b-c)/j+(b<c?6:0);break;case b:g=(c-a)/j+2;break;case c:g=(a-b)/j+4}g/=6}return{h:g*360,s:h,l:i,a:d}},toARGB:function(){var a=[Math.round(this.alpha*255)].concat(this.rgb);return"#"+a.map(function(a){return a=Math.round(a),a=(a>255?255:a<0?0:a).toString(16),a.length===1?"0"+a:a}).join("")}}}(c("../tree")),function(a){a.Comment=function(a,b){this.value=a,this.silent=!!b},a.Comment.prototype={toCSS:function(a){return a.compress?"":this.value},eval:function(){return this}}}(c("../tree")),function(a){a.Condition=function(a,b,c,d,e){this.op=a.trim(),this.lvalue=b,this.rvalue=c,this.index=d,this.negate=e},a.Condition.prototype.eval=function(a){var b=this.lvalue.eval(a),c=this.rvalue.eval(a),d=this.index,e,e=function(a){switch(a){case"and":return b&&c;case"or":return b||c;default:if(b.compare)e=b.compare(c);else if(c.compare)e=c.compare(b);else throw{type:"Type",message:"Unable to perform comparison",index:d};switch(e){case-1:return a==="<"||a==="=<";case 0:return a==="="||a===">="||a==="=<";case 1:return a===">"||a===">="}}}(this.op);return this.negate?!e:e}}(c("../tree")),function(a){a.Dimension=function(a,b){this.value=parseFloat(a),this.unit=b||null},a.Dimension.prototype={eval:function(){return this},toColor:function(){return new a.Color([this.value,this.value,this.value])},toCSS:function(){var a=this.value+this.unit;return a},operate:function(b,c){return new a.Dimension(a.operate(b,this.value,c.value),this.unit||c.unit)},compare:function(b){return b instanceof a.Dimension?b.value>this.value?-1:b.value<this.value?1:0:-1}}}(c("../tree")),function(a){a.Directive=function(b,c,d){this.name=b,Array.isArray(c)?(this.ruleset=new a.Ruleset([],c),this.ruleset.allowImports=!0):this.value=c},a.Directive.prototype={toCSS:function(a,b){return this.ruleset?(this.ruleset.root=!0,this.name+(b.compress?"{":" {\n  ")+this.ruleset.toCSS(a,b).trim().replace(/\n/g,"\n  ")+(b.compress?"}":"\n}\n")):this.name+" "+this.value.toCSS()+";\n"},eval:function(a){return a.frames.unshift(this),this.ruleset=this.ruleset&&this.ruleset.eval(a),a.frames.shift(),this},variable:function(b){return a.Ruleset.prototype.variable.call(this.ruleset,b)},find:function(){return a.Ruleset.prototype.find.apply(this.ruleset,arguments)},rulesets:function(){return a.Ruleset.prototype.rulesets.apply(this.ruleset)}}}(c("../tree")),function(a){a.Element=function(b,c,d){this.combinator=b instanceof a.Combinator?b:new a.Combinator(b),typeof c=="string"?this.value=c.trim():c?this.value=c:this.value="",this.index=d},a.Element.prototype.eval=function(b){return new a.Element(this.combinator,this.value.eval?this.value.eval(b):this.value,this.index)},a.Element.prototype.toCSS=function(a){return this.combinator.toCSS(a||{})+(this.value.toCSS?this.value.toCSS(a):this.value)},a.Combinator=function(a){a===" "?this.value=" ":a==="& "?this.value="& ":this.value=a?a.trim():""},a.Combinator.prototype.toCSS=function(a){return{"":""," ":" ","&":"","& ":" ",":":" :","+":a.compress?"+":" + ","~":a.compress?"~":" ~ ",">":a.compress?">":" > "}[this.value]}}(c("../tree")),function(a){a.Expression=function(a){this.value=a},a.Expression.prototype={eval:function(b){return this.value.length>1?new a.Expression(this.value.map(function(a){return a.eval(b)})):this.value.length===1?this.value[0].eval(b):this},toCSS:function(a){return this.value.map(function(b){return b.toCSS?b.toCSS(a):""}).join(" ")}}}(c("../tree")),function(a){a.Import=function(b,c,d,e){var f=this;this.index=e,this._path=b,this.features=d&&new a.Value(d),b instanceof a.Quoted?this.path=/\.(le?|c)ss(\?.*)?$/.test(b.value)?b.value:b.value+".less":this.path=b.value.value||b.value,this.css=/css(\?.*)?$/.test(this.path),this.css||c.push(this.path,function(b,c){b&&(b.index=e),f.root=c||new a.Ruleset([],[])})},a.Import.prototype={toCSS:function(a){var b=this.features?" "+this.features.toCSS(a):"";return this.css?"@import "+this._path.toCSS()+b+";\n":""},eval:function(b){var c,d=this.features&&this.features.eval(b);if(this.css)return this;c=new a.Ruleset([],this.root.rules.slice(0));for(var e=0;e<c.rules.length;e++)c.rules[e]instanceof a.Import&&Array.prototype
+.splice.apply(c.rules,[e,1].concat(c.rules[e].eval(b)));return this.features?new a.Media(c.rules,this.features.value):c.rules}}}(c("../tree")),function(a){a.JavaScript=function(a,b,c){this.escaped=c,this.expression=a,this.index=b},a.JavaScript.prototype={eval:function(b){var c,d=this,e={},f=this.expression.replace(/@\{([\w-]+)\}/g,function(c,e){return a.jsify((new a.Variable("@"+e,d.index)).eval(b))});try{f=new Function("return ("+f+")")}catch(g){throw{message:"JavaScript evaluation error: `"+f+"`",index:this.index}}for(var h in b.frames[0].variables())e[h.slice(1)]={value:b.frames[0].variables()[h].value,toJS:function(){return this.value.eval(b).toCSS()}};try{c=f.call(e)}catch(g){throw{message:"JavaScript evaluation error: '"+g.name+": "+g.message+"'",index:this.index}}return typeof c=="string"?new a.Quoted('"'+c+'"',c,this.escaped,this.index):Array.isArray(c)?new a.Anonymous(c.join(", ")):new a.Anonymous(c)}}}(c("../tree")),function(a){a.Keyword=function(a){this.value=a},a.Keyword.prototype={eval:function(){return this},toCSS:function(){return this.value},compare:function(b){return b instanceof a.Keyword?b.value===this.value?0:1:-1}},a.True=new a.Keyword("true"),a.False=new a.Keyword("false")}(c("../tree")),function(a){a.Media=function(b,c){var d=new a.Element("&",null,0),e=[new a.Selector([d])];this.features=new a.Value(c),this.ruleset=new a.Ruleset(e,b),this.ruleset.allowImports=!0},a.Media.prototype={toCSS:function(a,b){var c=this.features.toCSS(b);return this.ruleset.root=a.length===0||a[0].multiMedia,"@media "+c+(b.compress?"{":" {\n  ")+this.ruleset.toCSS(a,b).trim().replace(/\n/g,"\n  ")+(b.compress?"}":"\n}\n")},eval:function(b){b.mediaBlocks||(b.mediaBlocks=[],b.mediaPath=[]);var c=b.mediaBlocks.length;b.mediaPath.push(this),b.mediaBlocks.push(this);var d=new a.Media([],[]);return d.features=this.features.eval(b),b.frames.unshift(this.ruleset),d.ruleset=this.ruleset.eval(b),b.frames.shift(),b.mediaBlocks[c]=d,b.mediaPath.pop(),b.mediaPath.length===0?d.evalTop(b):d.evalNested(b)},variable:function(b){return a.Ruleset.prototype.variable.call(this.ruleset,b)},find:function(){return a.Ruleset.prototype.find.apply(this.ruleset,arguments)},rulesets:function(){return a.Ruleset.prototype.rulesets.apply(this.ruleset)},evalTop:function(b){var c=this;if(b.mediaBlocks.length>1){var d=new a.Element("&",null,0),e=[new a.Selector([d])];c=new a.Ruleset(e,b.mediaBlocks),c.multiMedia=!0}return delete b.mediaBlocks,delete b.mediaPath,c},evalNested:function(b){var c,d,e=b.mediaPath.concat([this]);for(c=0;c<e.length;c++)d=e[c].features instanceof a.Value?e[c].features.value:e[c].features,e[c]=Array.isArray(d)?d:[d];return this.features=new a.Value(this.permute(e).map(function(b){b=b.map(function(b){return b.toCSS?b:new a.Anonymous(b)});for(c=b.length-1;c>0;c--)b.splice(c,0,new a.Anonymous("and"));return new a.Expression(b)})),new a.Ruleset([],[])},permute:function(a){if(a.length===0)return[];if(a.length===1)return a[0];var b=[],c=this.permute(a.slice(1));for(var d=0;d<c.length;d++)for(var e=0;e<a[0].length;e++)b.push([a[0][e]].concat(c[d]));return b}}}(c("../tree")),function(a){a.mixin={},a.mixin.Call=function(b,c,d,e,f){this.selector=new a.Selector(b),this.arguments=c,this.index=d,this.filename=e,this.important=f},a.mixin.Call.prototype={eval:function(a){var b,c,d=[],e=!1;for(var f=0;f<a.frames.length;f++)if((b=a.frames[f].find(this.selector)).length>0){c=this.arguments&&this.arguments.map(function(b){return b.eval(a)});for(var g=0;g<b.length;g++)if(b[g].match(c,a))try{Array.prototype.push.apply(d,b[g].eval(a,this.arguments,this.important).rules),e=!0}catch(h){throw{message:h.message,index:this.index,filename:this.filename,stack:h.stack}}if(e)return d;throw{type:"Runtime",message:"No matching definition was found for `"+this.selector.toCSS().trim()+"("+this.arguments.map(function(a){return a.toCSS()}).join(", ")+")`",index:this.index,filename:this.filename}}throw{type:"Name",message:this.selector.toCSS().trim()+" is undefined",index:this.index,filename:this.filename}}},a.mixin.Definition=function(b,c,d,e,f){this.name=b,this.selectors=[new a.Selector([new a.Element(null,b)])],this.params=c,this.condition=e,this.variadic=f,this.arity=c.length,this.rules=d,this._lookups={},this.required=c.reduce(function(a,b){return!b.name||b.name&&!b.value?a+1:a},0),this.parent=a.Ruleset.prototype,this.frames=[]},a.mixin.Definition.prototype={toCSS:function(){return""},variable:function(a){return this.parent.variable.call(this,a)},variables:function(){return this.parent.variables.call(this)},find:function(){return this.parent.find.apply(this,arguments)},rulesets:function(){return this.parent.rulesets.apply(this)},evalParams:function(b,c){var d=new a.Ruleset(null,[]),e;for(var f=0,g,h;f<this.params.length;f++)if(h=this.params[f].name)if(this.params[f].variadic&&c){e=[];for(var i=f;i<c.length;i++)e.push(c[i].eval(b));d.rules.unshift(new a.Rule(h,(new a.Expression(e)).eval(b)))}else if(g=c&&c[f]||this.params[f].value)d.rules.unshift(new a.Rule(h,g.eval(b)));else throw{type:"Runtime",message:"wrong number of arguments for "+this.name+" ("+c.length+" for "+this.arity+")"};return d},eval:function(b,c,d){var e=this.evalParams(b,c),f,g=[],h,i;for(var j=0;j<Math.max(this.params.length,c&&c.length);j++)g.push(c[j]||this.params[j].value);return e.rules.unshift(new a.Rule("@arguments",(new a.Expression(g)).eval(b))),h=d?this.rules.map(function(b){return new a.Rule(b.name,b.value,"!important",b.index)}):this.rules.slice(0),(new a.Ruleset(null,h)).eval({frames:[this,e].concat(this.frames,b.frames)})},match:function(a,b){var c=a&&a.length||0,d,e;if(!this.variadic){if(c<this.required)return!1;if(c>this.params.length)return!1;if(this.required>0&&c>this.params.length)return!1}if(this.condition&&!this.condition.eval({frames:[this.evalParams(b,a)].concat(b.frames)}))return!1;d=Math.min(c,this.arity);for(var f=0;f<d;f++)if(!this.params[f].name&&a[f].eval(b).toCSS()!=this.params[f].value.eval(b).toCSS())return!1;return!0}}}(c("../tree")),function(a){a.Operation=function(a,b){this.op=a.trim(),this.operands=b},a.Operation.prototype.eval=function(b){var c=this.operands[0].eval(b),d=this.operands[1].eval(b),e;if(c instanceof a.Dimension&&d instanceof a.Color)if(this.op==="*"||this.op==="+")e=d,d=c,c=e;else throw{name:"OperationError",message:"Can't substract or divide a color from a number"};return c.operate(this.op,d)},a.operate=function(a,b,c){switch(a){case"+":return b+c;case"-":return b-c;case"*":return b*c;case"/":return b/c}}}(c("../tree")),function(a){a.Paren=function(a){this.value=a},a.Paren.prototype={toCSS:function(a){return"("+this.value.toCSS(a)+")"},eval:function(b){return new a.Paren(this.value.eval(b))}}}(c("../tree")),function(a){a.Quoted=function(a,b,c,d){this.escaped=c,this.value=b||"",this.quote=a.charAt(0),this.index=d},a.Quoted.prototype={toCSS:function(){return this.escaped?this.value:this.quote+this.value+this.quote},eval:function(b){var c=this,d=this.value.replace(/`([^`]+)`/g,function(d,e){return(new a.JavaScript(e,c.index,!0)).eval(b).value}).replace(/@\{([\w-]+)\}/g,function(d,e){var f=(new a.Variable("@"+e,c.index)).eval(b);return"value"in f?f.value:f.toCSS()});return new a.Quoted(this.quote+d+this.quote,d,this.escaped,this.index)}}}(c("../tree")),function(a){a.Rule=function(b,c,d,e,f){this.name=b,this.value=c instanceof a.Value?c:new a.Value([c]),this.important=d?" "+d.trim():"",this.index=e,this.inline=f||!1,b.charAt(0)==="@"?this.variable=!0:this.variable=!1},a.Rule.prototype.toCSS=function(a){return this.variable?"":this.name+(a.compress?":":": ")+this.value.toCSS(a)+this.important+(this.inline?"":";")},a.Rule.prototype.eval=function(b){return new a.Rule(this.name,this.value.eval(b),this.important,this.index,this.inline)},a.Shorthand=function(a,b){this.a=a,this.b=b},a.Shorthand.prototype={toCSS:function(a){return this.a.toCSS(a)+"/"+this.b.toCSS(a)},eval:function(){return this}}}(c("../tree")),function(a){a.Ruleset=function(a,b,c){this.selectors=a,this.rules=b,this._lookups={},this.strictImports=c},a.Ruleset.prototype={eval:function(b){var c=this.selectors&&this.selectors.map(function(a){return a.eval(b)}),d=new a.Ruleset(c,this.rules.slice(0),this.strictImports);d.root=this.root,d.allowImports=this.allowImports,b.frames.unshift(d);if(d.root||d.allowImports||!d.strictImports)for(var e=0;e<d.rules.length;e++)d.rules[e]instanceof a.Import&&Array.prototype.splice.apply(d.rules,[e,1].concat(d.rules[e].eval(b)));for(var e=0;e<d.rules.length;e++)d.rules[e]instanceof a.mixin.Definition&&(d.rules[e].frames=b.frames.slice(0));for(var e=0;e<d.rules.length;e++)d.rules[e]instanceof a.mixin.Call&&Array.prototype.splice.apply(d.rules,[e,1].concat(d.rules[e].eval(b)));for(var e=0,f;e<d.rules.length;e++)f=d.rules[e],f instanceof a.mixin.Definition||(d.rules[e]=f.eval?f.eval(b):f);return b.frames.shift(),d},match:function(a){return!a||a.length===0},variables:function(){return this._variables?this._variables:this._variables=this.rules.reduce(function(b,c){return c instanceof a.Rule&&c.variable===!0&&(b[c.name]=c),b},{})},variable:function(a){return this.variables()[a]},rulesets:function(){return this._rulesets?this._rulesets:this._rulesets=this.rules.filter(function(b){return b instanceof a.Ruleset||b instanceof a.mixin.Definition})},find:function(b,c){c=c||this;var d=[],e,f,g=b.toCSS();return g in this._lookups?this._lookups[g]:(this.rulesets().forEach(function(e){if(e!==c)for(var g=0;g<e.selectors.length;g++)if(f=b.match(e.selectors[g])){b.elements.length>e.selectors[g].elements.length?Array.prototype.push.apply(d,e.find(new a.Selector(b.elements.slice(1)),c)):d.push(e);break}}),this._lookups[g]=d)},toCSS:function(b,c){var d=[],e=[],f=[],g=[],h,i;this.root||(b.length===0?g=this.selectors.map(function(a){return[a]}):this.joinSelectors(g,b,this.selectors));for(var j=0;j<this.rules.length;j++)i=this.rules[j],i.rules||i instanceof a.Directive||i instanceof a.Media?f.push(i.toCSS(g,c)):i instanceof a.Comment?i.silent||(this.root?f.push(i.toCSS(c)):e.push(i.toCSS(c))):i.toCSS&&!i.variable?e.push(i.toCSS(c)):i.value&&!i.variable&&e.push(i.value.toString());return f=f.join(""),this.root?d.push(e.join(c.compress?"":"\n")):e.length>0&&(h=g.map(function(a){return a.map(function(a){return a.toCSS(c)}).join("").trim()}).join(c.compress?",":",\n"),d.push(h,(c.compress?"{":" {\n  ")+e.join(c.compress?"":"\n  ")+(c.compress?"}":"\n}\n"))),d.push(f),d.join("")+(c.compress?"\n":"")},joinSelectors:function(a,b,c){for(var d=0;d<c.length;d++)this.joinSelector(a,b,c[d])},joinSelector:function(b,c,d){var e=[],f=[],g=[],h=[],i=!1,j;for(var k=0;k<d.elements.length;k++)j=d.elements[k],j.combinator.value.charAt(0)==="&"&&(i=!0),i?h.push(j):g.push(j);i||(h=g,g=[]),g.length>0&&e.push(new a.Selector(g)),h.length>0&&f.push(new a.Selector(h));for(var l=0;l<c.length;l++)b.push(e.concat(c[l]).concat(f))}}}(c("../tree")),function(a){a.Selector=function(a){this.elements=a,this.elements[0].combinator.value===""&&(this.elements[0].combinator.value=" ")},a.Selector.prototype.match=function(a){var b=this.elements.length,c=a.elements.length,d=Math.min(b,c);if(b<c)return!1;for(var e=0;e<d;e++)if(this.elements[e].value!==a.elements[e].value)return!1;return!0},a.Selector.prototype.eval=function(b){return new a.Selector(this.elements.map(function(a){return a.eval(b)}))},a.Selector.prototype.toCSS=function(a){return this._css?this._css:this._css=this.elements.map(function(b){return typeof b=="string"?" "+b.trim():b.toCSS(a)}).join("")}}(c("../tree")),function(b){b.URL=function(b,c){b.data?this.attrs=b:(typeof a!="undefined"&&!/^(?:https?:\/\/|file:\/\/|data:|\/)/.test(b.value)&&c.length>0&&(b.value=c[0]+(b.value.charAt(0)==="/"?b.value.slice(1):b.value)),this.value=b,this.paths=c)},b.URL.prototype={toCSS:function(){return"url("+(this.attrs?"data:"+this.attrs.mime+this.attrs.charset+this.attrs.base64+this.attrs.data:this.value.toCSS())+")"},eval:function(a){return this.attrs?this:new b.URL(this.value.eval(a),this.paths)}}}(c("../tree")),function(a){a.Value=function(a){this.value=a,this.is="value"},a.Value.prototype={eval:function(b){return this.value.length===1?this.value[0].eval(b):new a.Value(this.value.map(function(a){return a.eval(b)}))},toCSS:function(a){return this.value.map(function(b){return b.toCSS(a)}).join(a.compress?",":", ")}}}(c("../tree")),function(a){a.Variable=function(a,b,c){this.name=a,this.index=b,this.file=c},a.Variable.prototype={eval:function(b){var c,d,e=this.name;e.indexOf("@@")==0&&(e="@"+(new a.Variable(e.slice(1))).eval(b).value);if(c=a.find(b.frames,function(a){if(d=a.variable(e))return d.value.eval(b)}))return c;throw{type:"Name",message:"variable "+e+" is undefined",filename:this.file,index:this.index}}}}(c("../tree")),function(a){a.find=function(a,b){for(var c=0,d;c<a.length;c++)if(d=b.call(a,a[c]))return d;return null},a.jsify=function(a){return Array.isArray(a.value)&&a.value.length>1?"["+a.value.map(function(a){return a.toCSS(!1)}).join(", ")+"]":a.toCSS(!1)}}(c("./tree"));var f=location.protocol==="file:"||location.protocol==="chrome:"||location.protocol==="chrome-extension:"||location.protocol==="resource:";d.env=d.env||(location.hostname=="127.0.0.1"||location.hostname=="0.0.0.0"||location.hostname=="localhost"||location.port.length>0||f?"development":"production"),d.async=!1,d.poll=d.poll||(f?1e3:1500),d.watch=function(){return this.watchMode=!0},d.unwatch=function(){return this.watchMode=!1},d.env==="development"?(d.optimization=0,/!watch/.test(location.hash)&&d.watch(),d.watchTimer=setInterval(function(){d.watchMode&&m(function(a,b,c,d,e){b&&p(b.toCSS(),d,e.lastModified)})},d.poll)):d.optimization=3;var g;try{g=typeof a.localStorage=="undefined"?null:a.localStorage}catch(h){g=null}var i=document.getElementsByTagName("link"),j=/^text\/(x-)?less$/;d.sheets=[];for(var k=0;k<i.length;k++)(i[k].rel==="stylesheet/less"||i[k].rel.match(/stylesheet/)&&i[k].type.match(j))&&d.sheets.push(i[k]);d.refresh=function(a){var b,c;b=c=new Date,m(function(a,d,e,f,g){g.local?t("loading "+f.href+" from cache."):(t("parsed "+f.href+" successfully."),p(d.toCSS(),f,g.lastModified)),t("css for "+f.href+" generated in "+(new Date-c)+"ms"),g.remaining===0&&t("css generated in "+(new Date-b)+"ms"),c=new Date},a),l()},d.refreshStyles=l,d.refresh(d.env==="development")})(window);
\ No newline at end of file
diff --git a/module/web/static/js/libs/lodash-1.0.1.js b/module/web/static/js/libs/lodash-1.0.1.js
new file mode 100644
index 000000000..9a78cd589
--- /dev/null
+++ b/module/web/static/js/libs/lodash-1.0.1.js
@@ -0,0 +1,5049 @@
+/**
+ * @license
+ * Lo-Dash 1.0.1 (Custom Build) <http://lodash.com/>
+ * Build: `lodash modern -o ./dist/lodash.js`
+ * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+ * Based on Underscore.js 1.4.4 <http://underscorejs.org/>
+ * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud Inc.
+ * Available under MIT license <http://lodash.com/license>
+ */
+;(function(window) {
+
+  /** Used as a safe reference for `undefined` in pre ES5 environments */
+  var undefined;
+
+  /** Detect free variable `exports` */
+  var freeExports = typeof exports == 'object' && exports;
+
+  /** Detect free variable `module` */
+  var freeModule = typeof module == 'object' && module && module.exports == freeExports && module;
+
+  /** Detect free variable `global` and use it as `window` */
+  var freeGlobal = typeof global == 'object' && global;
+  if (freeGlobal.global === freeGlobal) {
+    window = freeGlobal;
+  }
+
+  /** Used to generate unique IDs */
+  var idCounter = 0;
+
+  /** Used internally to indicate various things */
+  var indicatorObject = {};
+
+  /** Used by `cachedContains` as the default size when optimizations are enabled for large arrays */
+  var largeArraySize = 30;
+
+  /** Used to match HTML entities */
+  var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g;
+
+  /** Used to match empty string literals in compiled template source */
+  var reEmptyStringLeading = /\b__p \+= '';/g,
+      reEmptyStringMiddle = /\b(__p \+=) '' \+/g,
+      reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;
+
+  /** Used to match regexp flags from their coerced string values */
+  var reFlags = /\w*$/;
+
+  /**
+   * Used to match ES6 template delimiters
+   * http://people.mozilla.org/~jorendorff/es6-draft.html#sec-7.8.6
+   */
+  var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;
+
+  /** Used to match "interpolate" template delimiters */
+  var reInterpolate = /<%=([\s\S]+?)%>/g;
+
+  /** Used to ensure capturing order of template delimiters */
+  var reNoMatch = /($^)/;
+
+  /** Used to match HTML characters */
+  var reUnescapedHtml = /[&<>"']/g;
+
+  /** Used to match unescaped characters in compiled string literals */
+  var reUnescapedString = /['\n\r\t\u2028\u2029\\]/g;
+
+  /** Used to assign default `context` object properties */
+  var contextProps = [
+    'Array', 'Boolean', 'Date', 'Function', 'Math', 'Number', 'Object', 'RegExp',
+    'String', '_', 'attachEvent', 'clearTimeout', 'isFinite', 'isNaN', 'parseInt',
+    'setImmediate', 'setTimeout'
+  ];
+
+  /** Used to make template sourceURLs easier to identify */
+  var templateCounter = 0;
+
+  /** `Object#toString` result shortcuts */
+  var argsClass = '[object Arguments]',
+      arrayClass = '[object Array]',
+      boolClass = '[object Boolean]',
+      dateClass = '[object Date]',
+      funcClass = '[object Function]',
+      numberClass = '[object Number]',
+      objectClass = '[object Object]',
+      regexpClass = '[object RegExp]',
+      stringClass = '[object String]';
+
+  /** Used to identify object classifications that `_.clone` supports */
+  var cloneableClasses = {};
+  cloneableClasses[funcClass] = false;
+  cloneableClasses[argsClass] = cloneableClasses[arrayClass] =
+  cloneableClasses[boolClass] = cloneableClasses[dateClass] =
+  cloneableClasses[numberClass] = cloneableClasses[objectClass] =
+  cloneableClasses[regexpClass] = cloneableClasses[stringClass] = true;
+
+  /** Used to determine if values are of the language type Object */
+  var objectTypes = {
+    'boolean': false,
+    'function': true,
+    'object': true,
+    'number': false,
+    'string': false,
+    'undefined': false
+  };
+
+  /** Used to escape characters for inclusion in compiled string literals */
+  var stringEscapes = {
+    '\\': '\\',
+    "'": "'",
+    '\n': 'n',
+    '\r': 'r',
+    '\t': 't',
+    '\u2028': 'u2028',
+    '\u2029': 'u2029'
+  };
+
+  /*--------------------------------------------------------------------------*/
+
+  /**
+   * Create a new `lodash` function using the given `context` object.
+   *
+   * @static
+   * @memberOf _
+   * @category Utilities
+   * @param {Object} [context=window] The context object.
+   * @returns {Function} Returns the `lodash` function.
+   */
+  function runInContext(context) {
+    context = context ? _.defaults({}, context, _.pick(window, contextProps)) : window;
+
+    /** Native constructor references */
+    var Array = context.Array,
+        Boolean = context.Boolean,
+        Date = context.Date,
+        Function = context.Function,
+        Math = context.Math,
+        Number = context.Number,
+        Object = context.Object,
+        RegExp = context.RegExp,
+        String = context.String;
+
+    /** Used for `Array` and `Object` method references */
+    var arrayRef = Array(),
+        objectRef = Object();
+
+    /** Used to restore the original `_` reference in `noConflict` */
+    var oldDash = context._;
+
+    /** Used to detect if a method is native */
+    var reNative = RegExp('^' +
+      (objectRef.valueOf + '')
+        .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+        .replace(/valueOf|for [^\]]+/g, '.+?') + '$'
+    );
+
+    /** Native method shortcuts */
+    var ceil = Math.ceil,
+        clearTimeout = context.clearTimeout,
+        concat = arrayRef.concat,
+        floor = Math.floor,
+        getPrototypeOf = reNative.test(getPrototypeOf = Object.getPrototypeOf) && getPrototypeOf,
+        hasOwnProperty = objectRef.hasOwnProperty,
+        push = arrayRef.push,
+        setImmediate = context.setImmediate,
+        setTimeout = context.setTimeout,
+        toString = objectRef.toString;
+
+    /* Native method shortcuts for methods with the same name as other `lodash` methods */
+    var nativeBind = reNative.test(nativeBind = slice.bind) && nativeBind,
+        nativeIsArray = reNative.test(nativeIsArray = Array.isArray) && nativeIsArray,
+        nativeIsFinite = context.isFinite,
+        nativeIsNaN = context.isNaN,
+        nativeKeys = reNative.test(nativeKeys = Object.keys) && nativeKeys,
+        nativeMax = Math.max,
+        nativeMin = Math.min,
+        nativeParseInt = context.parseInt,
+        nativeRandom = Math.random;
+
+    /** Detect various environments */
+    var isIeOpera = reNative.test(context.attachEvent),
+        isJSC = !/\n{2,}/.test(Function()),
+        isV8 = nativeBind && !/\n|true/.test(nativeBind + isIeOpera);
+
+    /* Detect if `Function#bind` exists and is inferred to be fast (all but V8) */
+    var isBindFast = nativeBind && !isV8;
+
+    /* Detect if `Object.keys` exists and is inferred to be fast (Firefox, IE, Opera, V8) */
+    var isKeysFast = nativeKeys && (isIeOpera || isV8 || !isJSC);
+
+    /** Used to lookup a built-in constructor by [[Class]] */
+    var ctorByClass = {};
+    ctorByClass[arrayClass] = Array;
+    ctorByClass[boolClass] = Boolean;
+    ctorByClass[dateClass] = Date;
+    ctorByClass[objectClass] = Object;
+    ctorByClass[numberClass] = Number;
+    ctorByClass[regexpClass] = RegExp;
+    ctorByClass[stringClass] = String;
+
+    /*--------------------------------------------------------------------------*/
+
+    /**
+     * Creates a `lodash` object, that wraps the given `value`, to enable method
+     * chaining.
+     *
+     * In addition to Lo-Dash methods, wrappers also have the following `Array` methods:
+     * `concat`, `join`, `pop`, `push`, `reverse`, `shift`, `slice`, `sort`, `splice`,
+     * and `unshift`
+     *
+     * Chaining is supported in custom builds as long as the `value` method is
+     * implicitly or explicitly included in the build.
+     *
+     * The chainable wrapper functions are:
+     * `after`, `assign`, `bind`, `bindAll`, `bindKey`, `chain`, `compact`, `compose`,
+     * `concat`, `countBy`, `debounce`, `defaults`, `defer`, `delay`, `difference`,
+     * `filter`, `flatten`, `forEach`, `forIn`, `forOwn`, `functions`, `groupBy`,
+     * `initial`, `intersection`, `invert`, `invoke`, `keys`, `map`, `max`, `memoize`,
+     * `merge`, `min`, `object`, `omit`, `once`, `pairs`, `partial`, `partialRight`,
+     * `pick`, `pluck`, `push`, `range`, `reject`, `rest`, `reverse`, `shuffle`,
+     * `slice`, `sort`, `sortBy`, `splice`, `tap`, `throttle`, `times`, `toArray`,
+     * `union`, `uniq`, `unshift`, `values`, `where`, `without`, `wrap`, and `zip`
+     *
+     * The non-chainable wrapper functions are:
+     * `clone`, `cloneDeep`, `contains`, `escape`, `every`, `find`, `has`,
+     * `identity`, `indexOf`, `isArguments`, `isArray`, `isBoolean`, `isDate`,
+     * `isElement`, `isEmpty`, `isEqual`, `isFinite`, `isFunction`, `isNaN`,
+     * `isNull`, `isNumber`, `isObject`, `isPlainObject`, `isRegExp`, `isString`,
+     * `isUndefined`, `join`, `lastIndexOf`, `mixin`, `noConflict`, `parseInt`,
+     * `pop`, `random`, `reduce`, `reduceRight`, `result`, `shift`, `size`, `some`,
+     * `sortedIndex`, `runInContext`, `template`, `unescape`, `uniqueId`, and `value`
+     *
+     * The wrapper functions `first` and `last` return wrapped values when `n` is
+     * passed, otherwise they return unwrapped values.
+     *
+     * @name _
+     * @constructor
+     * @category Chaining
+     * @param {Mixed} value The value to wrap in a `lodash` instance.
+     * @returns {Object} Returns a `lodash` instance.
+     */
+    function lodash(value) {
+      // exit early if already wrapped, even if wrapped by a different `lodash` constructor
+      if (value && typeof value == 'object' && value.__wrapped__) {
+        return value;
+      }
+      // allow invoking `lodash` without the `new` operator
+      if (!(this instanceof lodash)) {
+        return new lodash(value);
+      }
+      this.__wrapped__ = value;
+    }
+
+    /**
+     * By default, the template delimiters used by Lo-Dash are similar to those in
+     * embedded Ruby (ERB). Change the following template settings to use alternative
+     * delimiters.
+     *
+     * @static
+     * @memberOf _
+     * @type Object
+     */
+    lodash.templateSettings = {
+
+      /**
+       * Used to detect `data` property values to be HTML-escaped.
+       *
+       * @memberOf _.templateSettings
+       * @type RegExp
+       */
+      'escape': /<%-([\s\S]+?)%>/g,
+
+      /**
+       * Used to detect code to be evaluated.
+       *
+       * @memberOf _.templateSettings
+       * @type RegExp
+       */
+      'evaluate': /<%([\s\S]+?)%>/g,
+
+      /**
+       * Used to detect `data` property values to inject.
+       *
+       * @memberOf _.templateSettings
+       * @type RegExp
+       */
+      'interpolate': reInterpolate,
+
+      /**
+       * Used to reference the data object in the template text.
+       *
+       * @memberOf _.templateSettings
+       * @type String
+       */
+      'variable': '',
+
+      /**
+       * Used to import variables into the compiled template.
+       *
+       * @memberOf _.templateSettings
+       * @type Object
+       */
+      'imports': {
+
+        /**
+         * A reference to the `lodash` function.
+         *
+         * @memberOf _.templateSettings.imports
+         * @type Function
+         */
+        '_': lodash
+      }
+    };
+
+    /*--------------------------------------------------------------------------*/
+
+    /**
+     * The template used to create iterator functions.
+     *
+     * @private
+     * @param {Obect} data The data object used to populate the text.
+     * @returns {String} Returns the interpolated text.
+     */
+    var iteratorTemplate = function(obj) {
+      
+      var __p = 'var index, iterable = ' +
+      (obj.firstArg ) +
+      ', result = iterable;\nif (!iterable) return result;\n' +
+      (obj.top ) +
+      ';\n';
+       if (obj.arrays) {
+      __p += 'var length = iterable.length; index = -1;\nif (' +
+      (obj.arrays ) +
+      ') {\n  while (++index < length) {\n    ' +
+      (obj.loop ) +
+      '\n  }\n}\nelse {  ';
+       } ;
+      
+       if (obj.isKeysFast && obj.useHas) {
+      __p += '\n  var ownIndex = -1,\n      ownProps = objectTypes[typeof iterable] ? nativeKeys(iterable) : [],\n      length = ownProps.length;\n\n  while (++ownIndex < length) {\n    index = ownProps[ownIndex];\n    ' +
+      (obj.loop ) +
+      '\n  }  ';
+       } else {
+      __p += '\n  for (index in iterable) {';
+          if (obj.useHas) {
+      __p += '\n    if (';
+            if (obj.useHas) {
+      __p += 'hasOwnProperty.call(iterable, index)';
+       }    ;
+      __p += ') {    ';
+       } ;
+      __p += 
+      (obj.loop ) +
+      ';    ';
+       if (obj.useHas) {
+      __p += '\n    }';
+       } ;
+      __p += '\n  }  ';
+       } ;
+      
+       if (obj.arrays) {
+      __p += '\n}';
+       } ;
+      __p += 
+      (obj.bottom ) +
+      ';\nreturn result';
+      
+      
+      return __p
+    };
+
+    /** Reusable iterator options for `assign` and `defaults` */
+    var defaultsIteratorOptions = {
+      'args': 'object, source, guard',
+      'top':
+        'var args = arguments,\n' +
+        '    argsIndex = 0,\n' +
+        "    argsLength = typeof guard == 'number' ? 2 : args.length;\n" +
+        'while (++argsIndex < argsLength) {\n' +
+        '  iterable = args[argsIndex];\n' +
+        '  if (iterable && objectTypes[typeof iterable]) {',
+      'loop': "if (typeof result[index] == 'undefined') result[index] = iterable[index]",
+      'bottom': '  }\n}'
+    };
+
+    /** Reusable iterator options shared by `each`, `forIn`, and `forOwn` */
+    var eachIteratorOptions = {
+      'args': 'collection, callback, thisArg',
+      'top': "callback = callback && typeof thisArg == 'undefined' ? callback : createCallback(callback, thisArg)",
+      'arrays': "typeof length == 'number'",
+      'loop': 'if (callback(iterable[index], index, collection) === false) return result'
+    };
+
+    /** Reusable iterator options for `forIn` and `forOwn` */
+    var forOwnIteratorOptions = {
+      'top': 'if (!objectTypes[typeof iterable]) return result;\n' + eachIteratorOptions.top,
+      'arrays': false
+    };
+
+    /*--------------------------------------------------------------------------*/
+
+    /**
+     * Creates a function optimized to search large arrays for a given `value`,
+     * starting at `fromIndex`, using strict equality for comparisons, i.e. `===`.
+     *
+     * @private
+     * @param {Array} array The array to search.
+     * @param {Mixed} value The value to search for.
+     * @param {Number} [fromIndex=0] The index to search from.
+     * @param {Number} [largeSize=30] The length at which an array is considered large.
+     * @returns {Boolean} Returns `true`, if `value` is found, else `false`.
+     */
+    function cachedContains(array, fromIndex, largeSize) {
+      fromIndex || (fromIndex = 0);
+
+      var length = array.length,
+          isLarge = (length - fromIndex) >= (largeSize || largeArraySize);
+
+      if (isLarge) {
+        var cache = {},
+            index = fromIndex - 1;
+
+        while (++index < length) {
+          // manually coerce `value` to a string because `hasOwnProperty`, in some
+          // older versions of Firefox, coerces objects incorrectly
+          var key = array[index] + '';
+          (hasOwnProperty.call(cache, key) ? cache[key] : (cache[key] = [])).push(array[index]);
+        }
+      }
+      return function(value) {
+        if (isLarge) {
+          var key = value + '';
+          return hasOwnProperty.call(cache, key) && indexOf(cache[key], value) > -1;
+        }
+        return indexOf(array, value, fromIndex) > -1;
+      }
+    }
+
+    /**
+     * Used by `_.max` and `_.min` as the default `callback` when a given
+     * `collection` is a string value.
+     *
+     * @private
+     * @param {String} value The character to inspect.
+     * @returns {Number} Returns the code unit of given character.
+     */
+    function charAtCallback(value) {
+      return value.charCodeAt(0);
+    }
+
+    /**
+     * Used by `sortBy` to compare transformed `collection` values, stable sorting
+     * them in ascending order.
+     *
+     * @private
+     * @param {Object} a The object to compare to `b`.
+     * @param {Object} b The object to compare to `a`.
+     * @returns {Number} Returns the sort order indicator of `1` or `-1`.
+     */
+    function compareAscending(a, b) {
+      var ai = a.index,
+          bi = b.index;
+
+      a = a.criteria;
+      b = b.criteria;
+
+      // ensure a stable sort in V8 and other engines
+      // http://code.google.com/p/v8/issues/detail?id=90
+      if (a !== b) {
+        if (a > b || typeof a == 'undefined') {
+          return 1;
+        }
+        if (a < b || typeof b == 'undefined') {
+          return -1;
+        }
+      }
+      return ai < bi ? -1 : 1;
+    }
+
+    /**
+     * Creates a function that, when called, invokes `func` with the `this` binding
+     * of `thisArg` and prepends any `partialArgs` to the arguments passed to the
+     * bound function.
+     *
+     * @private
+     * @param {Function|String} func The function to bind or the method name.
+     * @param {Mixed} [thisArg] The `this` binding of `func`.
+     * @param {Array} partialArgs An array of arguments to be partially applied.
+     * @param {Object} [rightIndicator] Used to indicate partially applying arguments from the right.
+     * @returns {Function} Returns the new bound function.
+     */
+    function createBound(func, thisArg, partialArgs, rightIndicator) {
+      var isFunc = isFunction(func),
+          isPartial = !partialArgs,
+          key = thisArg;
+
+      // juggle arguments
+      if (isPartial) {
+        partialArgs = thisArg;
+      }
+      if (!isFunc) {
+        thisArg = func;
+      }
+
+      function bound() {
+        // `Function#bind` spec
+        // http://es5.github.com/#x15.3.4.5
+        var args = arguments,
+            thisBinding = isPartial ? this : thisArg;
+
+        if (!isFunc) {
+          func = thisArg[key];
+        }
+        if (partialArgs.length) {
+          args = args.length
+            ? (args = slice(args), rightIndicator ? args.concat(partialArgs) : partialArgs.concat(args))
+            : partialArgs;
+        }
+        if (this instanceof bound) {
+          // ensure `new bound` is an instance of `func`
+          noop.prototype = func.prototype;
+          thisBinding = new noop;
+          noop.prototype = null;
+
+          // mimic the constructor's `return` behavior
+          // http://es5.github.com/#x13.2.2
+          var result = func.apply(thisBinding, args);
+          return isObject(result) ? result : thisBinding;
+        }
+        return func.apply(thisBinding, args);
+      }
+      return bound;
+    }
+
+    /**
+     * Produces a callback bound to an optional `thisArg`. If `func` is a property
+     * name, the created callback will return the property value for a given element.
+     * If `func` is an object, the created callback will return `true` for elements
+     * that contain the equivalent object properties, otherwise it will return `false`.
+     *
+     * @private
+     * @param {Mixed} [func=identity] The value to convert to a callback.
+     * @param {Mixed} [thisArg] The `this` binding of the created callback.
+     * @param {Number} [argCount=3] The number of arguments the callback accepts.
+     * @returns {Function} Returns a callback function.
+     */
+    function createCallback(func, thisArg, argCount) {
+      if (func == null) {
+        return identity;
+      }
+      var type = typeof func;
+      if (type != 'function') {
+        if (type != 'object') {
+          return function(object) {
+            return object[func];
+          };
+        }
+        var props = keys(func);
+        return function(object) {
+          var length = props.length,
+              result = false;
+          while (length--) {
+            if (!(result = isEqual(object[props[length]], func[props[length]], indicatorObject))) {
+              break;
+            }
+          }
+          return result;
+        };
+      }
+      if (typeof thisArg != 'undefined') {
+        if (argCount === 1) {
+          return function(value) {
+            return func.call(thisArg, value);
+          };
+        }
+        if (argCount === 2) {
+          return function(a, b) {
+            return func.call(thisArg, a, b);
+          };
+        }
+        if (argCount === 4) {
+          return function(accumulator, value, index, object) {
+            return func.call(thisArg, accumulator, value, index, object);
+          };
+        }
+        return function(value, index, object) {
+          return func.call(thisArg, value, index, object);
+        };
+      }
+      return func;
+    }
+
+    /**
+     * Creates compiled iteration functions.
+     *
+     * @private
+     * @param {Object} [options1, options2, ...] The compile options object(s).
+     *  arrays - A string of code to determine if the iterable is an array or array-like.
+     *  useHas - A boolean to specify using `hasOwnProperty` checks in the object loop.
+     *  args - A string of comma separated arguments the iteration function will accept.
+     *  top - A string of code to execute before the iteration branches.
+     *  loop - A string of code to execute in the object loop.
+     *  bottom - A string of code to execute after the iteration branches.
+     * @returns {Function} Returns the compiled function.
+     */
+    function createIterator() {
+      var data = {
+        // support properties
+        'isKeysFast': isKeysFast,
+
+        // iterator options
+        'arrays': 'isArray(iterable)',
+        'bottom': '',
+        'loop': '',
+        'top': '',
+        'useHas': true
+      };
+
+      // merge options into a template data object
+      for (var object, index = 0; object = arguments[index]; index++) {
+        for (var key in object) {
+          data[key] = object[key];
+        }
+      }
+      var args = data.args;
+      data.firstArg = /^[^,]+/.exec(args)[0];
+
+      // create the function factory
+      var factory = Function(
+          'createCallback, hasOwnProperty, isArguments, isArray, isString, ' +
+          'objectTypes, nativeKeys',
+        'return function(' + args + ') {\n' + iteratorTemplate(data) + '\n}'
+      );
+      // return the compiled function
+      return factory(
+        createCallback, hasOwnProperty, isArguments, isArray, isString,
+        objectTypes, nativeKeys
+      );
+    }
+
+    /**
+     * A function compiled to iterate `arguments` objects, arrays, objects, and
+     * strings consistenly across environments, executing the `callback` for each
+     * element in the `collection`. The `callback` is bound to `thisArg` and invoked
+     * with three arguments; (value, index|key, collection). Callbacks may exit
+     * iteration early by explicitly returning `false`.
+     *
+     * @private
+     * @type Function
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Function} [callback=identity] The function called per iteration.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Array|Object|String} Returns `collection`.
+     */
+    var each = createIterator(eachIteratorOptions);
+
+    /**
+     * Used by `template` to escape characters for inclusion in compiled
+     * string literals.
+     *
+     * @private
+     * @param {String} match The matched character to escape.
+     * @returns {String} Returns the escaped character.
+     */
+    function escapeStringChar(match) {
+      return '\\' + stringEscapes[match];
+    }
+
+    /**
+     * Used by `escape` to convert characters to HTML entities.
+     *
+     * @private
+     * @param {String} match The matched character to escape.
+     * @returns {String} Returns the escaped character.
+     */
+    function escapeHtmlChar(match) {
+      return htmlEscapes[match];
+    }
+
+    /**
+     * Checks if `value` is a DOM node in IE < 9.
+     *
+     * @private
+     * @param {Mixed} value The value to check.
+     * @returns {Boolean} Returns `true` if the `value` is a DOM node, else `false`.
+     */
+    function isNode(value) {
+      // IE < 9 presents DOM nodes as `Object` objects except they have `toString`
+      // methods that are `typeof` "string" and still can coerce nodes to strings
+      return typeof value.toString != 'function' && typeof (value + '') == 'string';
+    }
+
+    /**
+     * A no-operation function.
+     *
+     * @private
+     */
+    function noop() {
+      // no operation performed
+    }
+
+    /**
+     * Slices the `collection` from the `start` index up to, but not including,
+     * the `end` index.
+     *
+     * Note: This function is used, instead of `Array#slice`, to support node lists
+     * in IE < 9 and to ensure dense arrays are returned.
+     *
+     * @private
+     * @param {Array|Object|String} collection The collection to slice.
+     * @param {Number} start The start index.
+     * @param {Number} end The end index.
+     * @returns {Array} Returns the new array.
+     */
+    function slice(array, start, end) {
+      start || (start = 0);
+      if (typeof end == 'undefined') {
+        end = array ? array.length : 0;
+      }
+      var index = -1,
+          length = end - start || 0,
+          result = Array(length < 0 ? 0 : length);
+
+      while (++index < length) {
+        result[index] = array[start + index];
+      }
+      return result;
+    }
+
+    /**
+     * Used by `unescape` to convert HTML entities to characters.
+     *
+     * @private
+     * @param {String} match The matched character to unescape.
+     * @returns {String} Returns the unescaped character.
+     */
+    function unescapeHtmlChar(match) {
+      return htmlUnescapes[match];
+    }
+
+    /*--------------------------------------------------------------------------*/
+
+    /**
+     * Checks if `value` is an `arguments` object.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} value The value to check.
+     * @returns {Boolean} Returns `true`, if the `value` is an `arguments` object, else `false`.
+     * @example
+     *
+     * (function() { return _.isArguments(arguments); })(1, 2, 3);
+     * // => true
+     *
+     * _.isArguments([1, 2, 3]);
+     * // => false
+     */
+    function isArguments(value) {
+      return toString.call(value) == argsClass;
+    }
+
+    /**
+     * Iterates over `object`'s own and inherited enumerable properties, executing
+     * the `callback` for each property. The `callback` is bound to `thisArg` and
+     * invoked with three arguments; (value, key, object). Callbacks may exit iteration
+     * early by explicitly returning `false`.
+     *
+     * @static
+     * @memberOf _
+     * @type Function
+     * @category Objects
+     * @param {Object} object The object to iterate over.
+     * @param {Function} [callback=identity] The function called per iteration.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Object} Returns `object`.
+     * @example
+     *
+     * function Dog(name) {
+     *   this.name = name;
+     * }
+     *
+     * Dog.prototype.bark = function() {
+     *   alert('Woof, woof!');
+     * };
+     *
+     * _.forIn(new Dog('Dagny'), function(value, key) {
+     *   alert(key);
+     * });
+     * // => alerts 'name' and 'bark' (order is not guaranteed)
+     */
+    var forIn = createIterator(eachIteratorOptions, forOwnIteratorOptions, {
+      'useHas': false
+    });
+
+    /**
+     * Iterates over an object's own enumerable properties, executing the `callback`
+     * for each property. The `callback` is bound to `thisArg` and invoked with three
+     * arguments; (value, key, object). Callbacks may exit iteration early by explicitly
+     * returning `false`.
+     *
+     * @static
+     * @memberOf _
+     * @type Function
+     * @category Objects
+     * @param {Object} object The object to iterate over.
+     * @param {Function} [callback=identity] The function called per iteration.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Object} Returns `object`.
+     * @example
+     *
+     * _.forOwn({ '0': 'zero', '1': 'one', 'length': 2 }, function(num, key) {
+     *   alert(key);
+     * });
+     * // => alerts '0', '1', and 'length' (order is not guaranteed)
+     */
+    var forOwn = createIterator(eachIteratorOptions, forOwnIteratorOptions);
+
+    /**
+     * Checks if `value` is an array.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} value The value to check.
+     * @returns {Boolean} Returns `true`, if the `value` is an array, else `false`.
+     * @example
+     *
+     * (function() { return _.isArray(arguments); })();
+     * // => false
+     *
+     * _.isArray([1, 2, 3]);
+     * // => true
+     */
+    var isArray = nativeIsArray || function(value) {
+      // `instanceof` may cause a memory leak in IE 7 if `value` is a host object
+      // http://ajaxian.com/archives/working-aroung-the-instanceof-memory-leak
+      return value instanceof Array || toString.call(value) == arrayClass;
+    };
+
+    /**
+     * Creates an array composed of the own enumerable property names of `object`.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Object} object The object to inspect.
+     * @returns {Array} Returns a new array of property names.
+     * @example
+     *
+     * _.keys({ 'one': 1, 'two': 2, 'three': 3 });
+     * // => ['one', 'two', 'three'] (order is not guaranteed)
+     */
+    var keys = !nativeKeys ? shimKeys : function(object) {
+      if (!isObject(object)) {
+        return [];
+      }
+      return nativeKeys(object);
+    };
+
+    /**
+     * A fallback implementation of `isPlainObject` that checks if a given `value`
+     * is an object created by the `Object` constructor, assuming objects created
+     * by the `Object` constructor have no inherited enumerable properties and that
+     * there are no `Object.prototype` extensions.
+     *
+     * @private
+     * @param {Mixed} value The value to check.
+     * @returns {Boolean} Returns `true`, if `value` is a plain object, else `false`.
+     */
+    function shimIsPlainObject(value) {
+      // avoid non-objects and false positives for `arguments` objects
+      var result = false;
+      if (!(value && typeof value == 'object') || isArguments(value)) {
+        return result;
+      }
+      // check that the constructor is `Object` (i.e. `Object instanceof Object`)
+      var ctor = value.constructor;
+      if ((!isFunction(ctor)) || ctor instanceof ctor) {
+        // In most environments an object's own properties are iterated before
+        // its inherited properties. If the last iterated property is an object's
+        // own property then there are no inherited enumerable properties.
+        forIn(value, function(value, key) {
+          result = key;
+        });
+        return result === false || hasOwnProperty.call(value, result);
+      }
+      return result;
+    }
+
+    /**
+     * A fallback implementation of `Object.keys` that produces an array of the
+     * given object's own enumerable property names.
+     *
+     * @private
+     * @param {Object} object The object to inspect.
+     * @returns {Array} Returns a new array of property names.
+     */
+    function shimKeys(object) {
+      var result = [];
+      forOwn(object, function(value, key) {
+        result.push(key);
+      });
+      return result;
+    }
+
+    /**
+     * Used to convert characters to HTML entities:
+     *
+     * Though the `>` character is escaped for symmetry, characters like `>` and `/`
+     * don't require escaping in HTML and have no special meaning unless they're part
+     * of a tag or an unquoted attribute value.
+     * http://mathiasbynens.be/notes/ambiguous-ampersands (under "semi-related fun fact")
+     */
+    var htmlEscapes = {
+      '&': '&amp;',
+      '<': '&lt;',
+      '>': '&gt;',
+      '"': '&quot;',
+      "'": '&#39;'
+    };
+
+    /** Used to convert HTML entities to characters */
+    var htmlUnescapes = invert(htmlEscapes);
+
+    /*--------------------------------------------------------------------------*/
+
+    /**
+     * Assigns own enumerable properties of source object(s) to the destination
+     * object. Subsequent sources will overwrite propery assignments of previous
+     * sources. If a `callback` function is passed, it will be executed to produce
+     * the assigned values. The `callback` is bound to `thisArg` and invoked with
+     * two arguments; (objectValue, sourceValue).
+     *
+     * @static
+     * @memberOf _
+     * @type Function
+     * @alias extend
+     * @category Objects
+     * @param {Object} object The destination object.
+     * @param {Object} [source1, source2, ...] The source objects.
+     * @param {Function} [callback] The function to customize assigning values.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Object} Returns the destination object.
+     * @example
+     *
+     * _.assign({ 'name': 'moe' }, { 'age': 40 });
+     * // => { 'name': 'moe', 'age': 40 }
+     *
+     * var defaults = _.partialRight(_.assign, function(a, b) {
+     *   return typeof a == 'undefined' ? b : a;
+     * });
+     *
+     * var food = { 'name': 'apple' };
+     * defaults(food, { 'name': 'banana', 'type': 'fruit' });
+     * // => { 'name': 'apple', 'type': 'fruit' }
+     */
+    var assign = createIterator(defaultsIteratorOptions, {
+      'top':
+        defaultsIteratorOptions.top.replace(';',
+          ';\n' +
+          "if (argsLength > 3 && typeof args[argsLength - 2] == 'function') {\n" +
+          '  var callback = createCallback(args[--argsLength - 1], args[argsLength--], 2);\n' +
+          "} else if (argsLength > 2 && typeof args[argsLength - 1] == 'function') {\n" +
+          '  callback = args[--argsLength];\n' +
+          '}'
+        ),
+      'loop': 'result[index] = callback ? callback(result[index], iterable[index]) : iterable[index]'
+    });
+
+    /**
+     * Creates a clone of `value`. If `deep` is `true`, nested objects will also
+     * be cloned, otherwise they will be assigned by reference. If a `callback`
+     * function is passed, it will be executed to produce the cloned values. If
+     * `callback` returns `undefined`, cloning will be handled by the method instead.
+     * The `callback` is bound to `thisArg` and invoked with one argument; (value).
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} value The value to clone.
+     * @param {Boolean} [deep=false] A flag to indicate a deep clone.
+     * @param {Function} [callback] The function to customize cloning values.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @param- {Array} [stackA=[]] Internally used to track traversed source objects.
+     * @param- {Array} [stackB=[]] Internally used to associate clones with source counterparts.
+     * @returns {Mixed} Returns the cloned `value`.
+     * @example
+     *
+     * var stooges = [
+     *   { 'name': 'moe', 'age': 40 },
+     *   { 'name': 'larry', 'age': 50 }
+     * ];
+     *
+     * var shallow = _.clone(stooges);
+     * shallow[0] === stooges[0];
+     * // => true
+     *
+     * var deep = _.clone(stooges, true);
+     * deep[0] === stooges[0];
+     * // => false
+     *
+     * _.mixin({
+     *   'clone': _.partialRight(_.clone, function(value) {
+     *     return _.isElement(value) ? value.cloneNode(false) : undefined;
+     *   })
+     * });
+     *
+     * var clone = _.clone(document.body);
+     * clone.childNodes.length;
+     * // => 0
+     */
+    function clone(value, deep, callback, thisArg, stackA, stackB) {
+      var result = value;
+
+      // allows working with "Collections" methods without using their `callback`
+      // argument, `index|key`, for this method's `callback`
+      if (typeof deep == 'function') {
+        thisArg = callback;
+        callback = deep;
+        deep = false;
+      }
+      if (typeof callback == 'function') {
+        callback = typeof thisArg == 'undefined' ? callback : createCallback(callback, thisArg, 1);
+        result = callback(result);
+
+        var done = typeof result != 'undefined';
+        if (!done) {
+          result = value;
+        }
+      }
+      // inspect [[Class]]
+      var isObj = isObject(result);
+      if (isObj) {
+        var className = toString.call(result);
+        if (!cloneableClasses[className]) {
+          return result;
+        }
+        var isArr = isArray(result);
+      }
+      // shallow clone
+      if (!isObj || !deep) {
+        return isObj && !done
+          ? (isArr ? slice(result) : assign({}, result))
+          : result;
+      }
+      var ctor = ctorByClass[className];
+      switch (className) {
+        case boolClass:
+        case dateClass:
+          return done ? result : new ctor(+result);
+
+        case numberClass:
+        case stringClass:
+          return done ? result : new ctor(result);
+
+        case regexpClass:
+          return done ? result : ctor(result.source, reFlags.exec(result));
+      }
+      // check for circular references and return corresponding clone
+      stackA || (stackA = []);
+      stackB || (stackB = []);
+
+      var length = stackA.length;
+      while (length--) {
+        if (stackA[length] == value) {
+          return stackB[length];
+        }
+      }
+      // init cloned object
+      if (!done) {
+        result = isArr ? ctor(result.length) : {};
+
+        // add array properties assigned by `RegExp#exec`
+        if (isArr) {
+          if (hasOwnProperty.call(value, 'index')) {
+            result.index = value.index;
+          }
+          if (hasOwnProperty.call(value, 'input')) {
+            result.input = value.input;
+          }
+        }
+      }
+      // add the source value to the stack of traversed objects
+      // and associate it with its clone
+      stackA.push(value);
+      stackB.push(result);
+
+      // recursively populate clone (susceptible to call stack limits)
+      (isArr ? forEach : forOwn)(done ? result : value, function(objValue, key) {
+        result[key] = clone(objValue, deep, callback, undefined, stackA, stackB);
+      });
+
+      return result;
+    }
+
+    /**
+     * Creates a deep clone of `value`. If a `callback` function is passed, it will
+     * be executed to produce the cloned values. If `callback` returns the value it
+     * was passed, cloning will be handled by the method instead. The `callback` is
+     * bound to `thisArg` and invoked with one argument; (value).
+     *
+     * Note: This function is loosely based on the structured clone algorithm. Functions
+     * and DOM nodes are **not** cloned. The enumerable properties of `arguments` objects and
+     * objects created by constructors other than `Object` are cloned to plain `Object` objects.
+     * See http://www.w3.org/TR/html5/infrastructure.html#internal-structured-cloning-algorithm.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} value The value to deep clone.
+     * @param {Function} [callback] The function to customize cloning values.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Mixed} Returns the deep cloned `value`.
+     * @example
+     *
+     * var stooges = [
+     *   { 'name': 'moe', 'age': 40 },
+     *   { 'name': 'larry', 'age': 50 }
+     * ];
+     *
+     * var deep = _.cloneDeep(stooges);
+     * deep[0] === stooges[0];
+     * // => false
+     *
+     * var view = {
+     *   'label': 'docs',
+     *   'node': element
+     * };
+     *
+     * var clone = _.cloneDeep(view, function(value) {
+     *   return _.isElement(value) ? value.cloneNode(true) : value;
+     * });
+     *
+     * clone.node == view.node;
+     * // => false
+     */
+    function cloneDeep(value, callback, thisArg) {
+      return clone(value, true, callback, thisArg);
+    }
+
+    /**
+     * Assigns own enumerable properties of source object(s) to the destination
+     * object for all destination properties that resolve to `undefined`. Once a
+     * property is set, additional defaults of the same property will be ignored.
+     *
+     * @static
+     * @memberOf _
+     * @type Function
+     * @category Objects
+     * @param {Object} object The destination object.
+     * @param {Object} [source1, source2, ...] The source objects.
+     * @param- {Object} [guard] Internally used to allow working with `_.reduce`
+     *  without using its callback's `key` and `object` arguments as sources.
+     * @returns {Object} Returns the destination object.
+     * @example
+     *
+     * var food = { 'name': 'apple' };
+     * _.defaults(food, { 'name': 'banana', 'type': 'fruit' });
+     * // => { 'name': 'apple', 'type': 'fruit' }
+     */
+    var defaults = createIterator(defaultsIteratorOptions);
+
+    /**
+     * Creates a sorted array of all enumerable properties, own and inherited,
+     * of `object` that have function values.
+     *
+     * @static
+     * @memberOf _
+     * @alias methods
+     * @category Objects
+     * @param {Object} object The object to inspect.
+     * @returns {Array} Returns a new array of property names that have function values.
+     * @example
+     *
+     * _.functions(_);
+     * // => ['all', 'any', 'bind', 'bindAll', 'clone', 'compact', 'compose', ...]
+     */
+    function functions(object) {
+      var result = [];
+      forIn(object, function(value, key) {
+        if (isFunction(value)) {
+          result.push(key);
+        }
+      });
+      return result.sort();
+    }
+
+    /**
+     * Checks if the specified object `property` exists and is a direct property,
+     * instead of an inherited property.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Object} object The object to check.
+     * @param {String} property The property to check for.
+     * @returns {Boolean} Returns `true` if key is a direct property, else `false`.
+     * @example
+     *
+     * _.has({ 'a': 1, 'b': 2, 'c': 3 }, 'b');
+     * // => true
+     */
+    function has(object, property) {
+      return object ? hasOwnProperty.call(object, property) : false;
+    }
+
+    /**
+     * Creates an object composed of the inverted keys and values of the given `object`.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Object} object The object to invert.
+     * @returns {Object} Returns the created inverted object.
+     * @example
+     *
+     *  _.invert({ 'first': 'moe', 'second': 'larry' });
+     * // => { 'moe': 'first', 'larry': 'second' } (order is not guaranteed)
+     */
+    function invert(object) {
+      var index = -1,
+          props = keys(object),
+          length = props.length,
+          result = {};
+
+      while (++index < length) {
+        var key = props[index];
+        result[object[key]] = key;
+      }
+      return result;
+    }
+
+    /**
+     * Checks if `value` is a boolean value.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} value The value to check.
+     * @returns {Boolean} Returns `true`, if the `value` is a boolean value, else `false`.
+     * @example
+     *
+     * _.isBoolean(null);
+     * // => false
+     */
+    function isBoolean(value) {
+      return value === true || value === false || toString.call(value) == boolClass;
+    }
+
+    /**
+     * Checks if `value` is a date.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} value The value to check.
+     * @returns {Boolean} Returns `true`, if the `value` is a date, else `false`.
+     * @example
+     *
+     * _.isDate(new Date);
+     * // => true
+     */
+    function isDate(value) {
+      return value instanceof Date || toString.call(value) == dateClass;
+    }
+
+    /**
+     * Checks if `value` is a DOM element.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} value The value to check.
+     * @returns {Boolean} Returns `true`, if the `value` is a DOM element, else `false`.
+     * @example
+     *
+     * _.isElement(document.body);
+     * // => true
+     */
+    function isElement(value) {
+      return value ? value.nodeType === 1 : false;
+    }
+
+    /**
+     * Checks if `value` is empty. Arrays, strings, or `arguments` objects with a
+     * length of `0` and objects with no own enumerable properties are considered
+     * "empty".
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Array|Object|String} value The value to inspect.
+     * @returns {Boolean} Returns `true`, if the `value` is empty, else `false`.
+     * @example
+     *
+     * _.isEmpty([1, 2, 3]);
+     * // => false
+     *
+     * _.isEmpty({});
+     * // => true
+     *
+     * _.isEmpty('');
+     * // => true
+     */
+    function isEmpty(value) {
+      var result = true;
+      if (!value) {
+        return result;
+      }
+      var className = toString.call(value),
+          length = value.length;
+
+      if ((className == arrayClass || className == stringClass ||
+          className == argsClass) ||
+          (className == objectClass && typeof length == 'number' && isFunction(value.splice))) {
+        return !length;
+      }
+      forOwn(value, function() {
+        return (result = false);
+      });
+      return result;
+    }
+
+    /**
+     * Performs a deep comparison between two values to determine if they are
+     * equivalent to each other. If `callback` is passed, it will be executed to
+     * compare values. If `callback` returns `undefined`, comparisons will be handled
+     * by the method instead. The `callback` is bound to `thisArg` and invoked with
+     * two arguments; (a, b).
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} a The value to compare.
+     * @param {Mixed} b The other value to compare.
+     * @param {Function} [callback] The function to customize comparing values.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @param- {Object} [stackA=[]] Internally used track traversed `a` objects.
+     * @param- {Object} [stackB=[]] Internally used track traversed `b` objects.
+     * @returns {Boolean} Returns `true`, if the values are equvalent, else `false`.
+     * @example
+     *
+     * var moe = { 'name': 'moe', 'age': 40 };
+     * var copy = { 'name': 'moe', 'age': 40 };
+     *
+     * moe == copy;
+     * // => false
+     *
+     * _.isEqual(moe, copy);
+     * // => true
+     *
+     * var words = ['hello', 'goodbye'];
+     * var otherWords = ['hi', 'goodbye'];
+     *
+     * _.isEqual(words, otherWords, function(a, b) {
+     *   var reGreet = /^(?:hello|hi)$/i,
+     *       aGreet = _.isString(a) && reGreet.test(a),
+     *       bGreet = _.isString(b) && reGreet.test(b);
+     *
+     *   return (aGreet || bGreet) ? (aGreet == bGreet) : undefined;
+     * });
+     * // => true
+     */
+    function isEqual(a, b, callback, thisArg, stackA, stackB) {
+      // used to indicate that when comparing objects, `a` has at least the properties of `b`
+      var whereIndicator = callback === indicatorObject;
+      if (callback && !whereIndicator) {
+        callback = typeof thisArg == 'undefined' ? callback : createCallback(callback, thisArg, 2);
+        var result = callback(a, b);
+        if (typeof result != 'undefined') {
+          return !!result;
+        }
+      }
+      // exit early for identical values
+      if (a === b) {
+        // treat `+0` vs. `-0` as not equal
+        return a !== 0 || (1 / a == 1 / b);
+      }
+      var type = typeof a,
+          otherType = typeof b;
+
+      // exit early for unlike primitive values
+      if (a === a &&
+          (!a || (type != 'function' && type != 'object')) &&
+          (!b || (otherType != 'function' && otherType != 'object'))) {
+        return false;
+      }
+      // exit early for `null` and `undefined`, avoiding ES3's Function#call behavior
+      // http://es5.github.com/#x15.3.4.4
+      if (a == null || b == null) {
+        return a === b;
+      }
+      // compare [[Class]] names
+      var className = toString.call(a),
+          otherClass = toString.call(b);
+
+      if (className == argsClass) {
+        className = objectClass;
+      }
+      if (otherClass == argsClass) {
+        otherClass = objectClass;
+      }
+      if (className != otherClass) {
+        return false;
+      }
+      switch (className) {
+        case boolClass:
+        case dateClass:
+          // coerce dates and booleans to numbers, dates to milliseconds and booleans
+          // to `1` or `0`, treating invalid dates coerced to `NaN` as not equal
+          return +a == +b;
+
+        case numberClass:
+          // treat `NaN` vs. `NaN` as equal
+          return a != +a
+            ? b != +b
+            // but treat `+0` vs. `-0` as not equal
+            : (a == 0 ? (1 / a == 1 / b) : a == +b);
+
+        case regexpClass:
+        case stringClass:
+          // coerce regexes to strings (http://es5.github.com/#x15.10.6.4)
+          // treat string primitives and their corresponding object instances as equal
+          return a == b + '';
+      }
+      var isArr = className == arrayClass;
+      if (!isArr) {
+        // unwrap any `lodash` wrapped values
+        if (a.__wrapped__ || b.__wrapped__) {
+          return isEqual(a.__wrapped__ || a, b.__wrapped__ || b, callback, thisArg, stackA, stackB);
+        }
+        // exit for functions and DOM nodes
+        if (className != objectClass) {
+          return false;
+        }
+        // in older versions of Opera, `arguments` objects have `Array` constructors
+        var ctorA = a.constructor,
+            ctorB = b.constructor;
+
+        // non `Object` object instances with different constructors are not equal
+        if (ctorA != ctorB && !(
+              isFunction(ctorA) && ctorA instanceof ctorA &&
+              isFunction(ctorB) && ctorB instanceof ctorB
+            )) {
+          return false;
+        }
+      }
+      // assume cyclic structures are equal
+      // the algorithm for detecting cyclic structures is adapted from ES 5.1
+      // section 15.12.3, abstract operation `JO` (http://es5.github.com/#x15.12.3)
+      stackA || (stackA = []);
+      stackB || (stackB = []);
+
+      var length = stackA.length;
+      while (length--) {
+        if (stackA[length] == a) {
+          return stackB[length] == b;
+        }
+      }
+      var size = 0;
+      result = true;
+
+      // add `a` and `b` to the stack of traversed objects
+      stackA.push(a);
+      stackB.push(b);
+
+      // recursively compare objects and arrays (susceptible to call stack limits)
+      if (isArr) {
+        length = a.length;
+        size = b.length;
+
+        // compare lengths to determine if a deep comparison is necessary
+        result = size == a.length;
+        if (!result && !whereIndicator) {
+          return result;
+        }
+        // deep compare the contents, ignoring non-numeric properties
+        while (size--) {
+          var index = length,
+              value = b[size];
+
+          if (whereIndicator) {
+            while (index--) {
+              if ((result = isEqual(a[index], value, callback, thisArg, stackA, stackB))) {
+                break;
+              }
+            }
+          } else if (!(result = isEqual(a[size], value, callback, thisArg, stackA, stackB))) {
+            break;
+          }
+        }
+        return result;
+      }
+      // deep compare objects using `forIn`, instead of `forOwn`, to avoid `Object.keys`
+      // which, in this case, is more costly
+      forIn(b, function(value, key, b) {
+        if (hasOwnProperty.call(b, key)) {
+          // count the number of properties.
+          size++;
+          // deep compare each property value.
+          return (result = hasOwnProperty.call(a, key) && isEqual(a[key], value, callback, thisArg, stackA, stackB));
+        }
+      });
+
+      if (result && !whereIndicator) {
+        // ensure both objects have the same number of properties
+        forIn(a, function(value, key, a) {
+          if (hasOwnProperty.call(a, key)) {
+            // `size` will be `-1` if `a` has more properties than `b`
+            return (result = --size > -1);
+          }
+        });
+      }
+      return result;
+    }
+
+    /**
+     * Checks if `value` is, or can be coerced to, a finite number.
+     *
+     * Note: This is not the same as native `isFinite`, which will return true for
+     * booleans and empty strings. See http://es5.github.com/#x15.1.2.5.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} value The value to check.
+     * @returns {Boolean} Returns `true`, if the `value` is finite, else `false`.
+     * @example
+     *
+     * _.isFinite(-101);
+     * // => true
+     *
+     * _.isFinite('10');
+     * // => true
+     *
+     * _.isFinite(true);
+     * // => false
+     *
+     * _.isFinite('');
+     * // => false
+     *
+     * _.isFinite(Infinity);
+     * // => false
+     */
+    function isFinite(value) {
+      return nativeIsFinite(value) && !nativeIsNaN(parseFloat(value));
+    }
+
+    /**
+     * Checks if `value` is a function.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} value The value to check.
+     * @returns {Boolean} Returns `true`, if the `value` is a function, else `false`.
+     * @example
+     *
+     * _.isFunction(_);
+     * // => true
+     */
+    function isFunction(value) {
+      return typeof value == 'function';
+    }
+
+    /**
+     * Checks if `value` is the language type of Object.
+     * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} value The value to check.
+     * @returns {Boolean} Returns `true`, if the `value` is an object, else `false`.
+     * @example
+     *
+     * _.isObject({});
+     * // => true
+     *
+     * _.isObject([1, 2, 3]);
+     * // => true
+     *
+     * _.isObject(1);
+     * // => false
+     */
+    function isObject(value) {
+      // check if the value is the ECMAScript language type of Object
+      // http://es5.github.com/#x8
+      // and avoid a V8 bug
+      // http://code.google.com/p/v8/issues/detail?id=2291
+      return value ? objectTypes[typeof value] : false;
+    }
+
+    /**
+     * Checks if `value` is `NaN`.
+     *
+     * Note: This is not the same as native `isNaN`, which will return `true` for
+     * `undefined` and other values. See http://es5.github.com/#x15.1.2.4.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} value The value to check.
+     * @returns {Boolean} Returns `true`, if the `value` is `NaN`, else `false`.
+     * @example
+     *
+     * _.isNaN(NaN);
+     * // => true
+     *
+     * _.isNaN(new Number(NaN));
+     * // => true
+     *
+     * isNaN(undefined);
+     * // => true
+     *
+     * _.isNaN(undefined);
+     * // => false
+     */
+    function isNaN(value) {
+      // `NaN` as a primitive is the only value that is not equal to itself
+      // (perform the [[Class]] check first to avoid errors with some host objects in IE)
+      return isNumber(value) && value != +value
+    }
+
+    /**
+     * Checks if `value` is `null`.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} value The value to check.
+     * @returns {Boolean} Returns `true`, if the `value` is `null`, else `false`.
+     * @example
+     *
+     * _.isNull(null);
+     * // => true
+     *
+     * _.isNull(undefined);
+     * // => false
+     */
+    function isNull(value) {
+      return value === null;
+    }
+
+    /**
+     * Checks if `value` is a number.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} value The value to check.
+     * @returns {Boolean} Returns `true`, if the `value` is a number, else `false`.
+     * @example
+     *
+     * _.isNumber(8.4 * 5);
+     * // => true
+     */
+    function isNumber(value) {
+      return typeof value == 'number' || toString.call(value) == numberClass;
+    }
+
+    /**
+     * Checks if a given `value` is an object created by the `Object` constructor.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} value The value to check.
+     * @returns {Boolean} Returns `true`, if `value` is a plain object, else `false`.
+     * @example
+     *
+     * function Stooge(name, age) {
+     *   this.name = name;
+     *   this.age = age;
+     * }
+     *
+     * _.isPlainObject(new Stooge('moe', 40));
+     * // => false
+     *
+     * _.isPlainObject([1, 2, 3]);
+     * // => false
+     *
+     * _.isPlainObject({ 'name': 'moe', 'age': 40 });
+     * // => true
+     */
+    var isPlainObject = function(value) {
+      if (!(value && typeof value == 'object')) {
+        return false;
+      }
+      var valueOf = value.valueOf,
+          objProto = typeof valueOf == 'function' && (objProto = getPrototypeOf(valueOf)) && getPrototypeOf(objProto);
+
+      return objProto
+        ? value == objProto || (getPrototypeOf(value) == objProto && !isArguments(value))
+        : shimIsPlainObject(value);
+    };
+
+    /**
+     * Checks if `value` is a regular expression.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} value The value to check.
+     * @returns {Boolean} Returns `true`, if the `value` is a regular expression, else `false`.
+     * @example
+     *
+     * _.isRegExp(/moe/);
+     * // => true
+     */
+    function isRegExp(value) {
+      return value instanceof RegExp || toString.call(value) == regexpClass;
+    }
+
+    /**
+     * Checks if `value` is a string.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} value The value to check.
+     * @returns {Boolean} Returns `true`, if the `value` is a string, else `false`.
+     * @example
+     *
+     * _.isString('moe');
+     * // => true
+     */
+    function isString(value) {
+      return typeof value == 'string' || toString.call(value) == stringClass;
+    }
+
+    /**
+     * Checks if `value` is `undefined`.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} value The value to check.
+     * @returns {Boolean} Returns `true`, if the `value` is `undefined`, else `false`.
+     * @example
+     *
+     * _.isUndefined(void 0);
+     * // => true
+     */
+    function isUndefined(value) {
+      return typeof value == 'undefined';
+    }
+
+    /**
+     * Recursively merges own enumerable properties of the source object(s), that
+     * don't resolve to `undefined`, into the destination object. Subsequent sources
+     * will overwrite propery assignments of previous sources. If a `callback` function
+     * is passed, it will be executed to produce the merged values of the destination
+     * and source properties. If `callback` returns `undefined`, merging will be
+     * handled by the method instead. The `callback` is bound to `thisArg` and
+     * invoked with two arguments; (objectValue, sourceValue).
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Object} object The destination object.
+     * @param {Object} [source1, source2, ...] The source objects.
+     * @param {Function} [callback] The function to customize merging properties.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @param- {Object} [deepIndicator] Internally used to indicate that `stackA`
+     *  and `stackB` are arrays of traversed objects instead of source objects.
+     * @param- {Array} [stackA=[]] Internally used to track traversed source objects.
+     * @param- {Array} [stackB=[]] Internally used to associate values with their
+     *  source counterparts.
+     * @returns {Object} Returns the destination object.
+     * @example
+     *
+     * var names = {
+     *   'stooges': [
+     *     { 'name': 'moe' },
+     *     { 'name': 'larry' }
+     *   ]
+     * };
+     *
+     * var ages = {
+     *   'stooges': [
+     *     { 'age': 40 },
+     *     { 'age': 50 }
+     *   ]
+     * };
+     *
+     * _.merge(names, ages);
+     * // => { 'stooges': [{ 'name': 'moe', 'age': 40 }, { 'name': 'larry', 'age': 50 }] }
+     *
+     * var food = {
+     *   'fruits': ['apple'],
+     *   'vegetables': ['beet']
+     * };
+     *
+     * var otherFood = {
+     *   'fruits': ['banana'],
+     *   'vegetables': ['carrot']
+     * };
+     *
+     * _.merge(food, otherFood, function(a, b) {
+     *   return _.isArray(a) ? a.concat(b) : undefined;
+     * });
+     * // => { 'fruits': ['apple', 'banana'], 'vegetables': ['beet', 'carrot] }
+     */
+    function merge(object, source, deepIndicator) {
+      var args = arguments,
+          index = 0,
+          length = 2;
+
+      if (!isObject(object)) {
+        return object;
+      }
+      if (deepIndicator === indicatorObject) {
+        var callback = args[3],
+            stackA = args[4],
+            stackB = args[5];
+      } else {
+        stackA = [];
+        stackB = [];
+
+        // allows working with `_.reduce` and `_.reduceRight` without
+        // using their `callback` arguments, `index|key` and `collection`
+        if (typeof deepIndicator != 'number') {
+          length = args.length;
+        }
+        if (length > 3 && typeof args[length - 2] == 'function') {
+          callback = createCallback(args[--length - 1], args[length--], 2);
+        } else if (length > 2 && typeof args[length - 1] == 'function') {
+          callback = args[--length];
+        }
+      }
+      while (++index < length) {
+        (isArray(args[index]) ? forEach : forOwn)(args[index], function(source, key) {
+          var found,
+              isArr,
+              result = source,
+              value = object[key];
+
+          if (source && ((isArr = isArray(source)) || isPlainObject(source))) {
+            // avoid merging previously merged cyclic sources
+            var stackLength = stackA.length;
+            while (stackLength--) {
+              if ((found = stackA[stackLength] == source)) {
+                value = stackB[stackLength];
+                break;
+              }
+            }
+            if (!found) {
+              value = isArr
+                ? (isArray(value) ? value : [])
+                : (isPlainObject(value) ? value : {});
+
+              if (callback) {
+                result = callback(value, source);
+                if (typeof result != 'undefined') {
+                  value = result;
+                }
+              }
+              // add `source` and associated `value` to the stack of traversed objects
+              stackA.push(source);
+              stackB.push(value);
+
+              // recursively merge objects and arrays (susceptible to call stack limits)
+              if (!callback) {
+                value = merge(value, source, indicatorObject, callback, stackA, stackB);
+              }
+            }
+          }
+          else {
+            if (callback) {
+              result = callback(value, source);
+              if (typeof result == 'undefined') {
+                result = source;
+              }
+            }
+            if (typeof result != 'undefined') {
+              value = result;
+            }
+          }
+          object[key] = value;
+        });
+      }
+      return object;
+    }
+
+    /**
+     * Creates a shallow clone of `object` excluding the specified properties.
+     * Property names may be specified as individual arguments or as arrays of
+     * property names. If a `callback` function is passed, it will be executed
+     * for each property in the `object`, omitting the properties `callback`
+     * returns truthy for. The `callback` is bound to `thisArg` and invoked
+     * with three arguments; (value, key, object).
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Object} object The source object.
+     * @param {Function|String} callback|[prop1, prop2, ...] The properties to omit
+     *  or the function called per iteration.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Object} Returns an object without the omitted properties.
+     * @example
+     *
+     * _.omit({ 'name': 'moe', 'age': 40 }, 'age');
+     * // => { 'name': 'moe' }
+     *
+     * _.omit({ 'name': 'moe', 'age': 40 }, function(value) {
+     *   return typeof value == 'number';
+     * });
+     * // => { 'name': 'moe' }
+     */
+    function omit(object, callback, thisArg) {
+      var isFunc = typeof callback == 'function',
+          result = {};
+
+      if (isFunc) {
+        callback = createCallback(callback, thisArg);
+      } else {
+        var props = concat.apply(arrayRef, arguments);
+      }
+      forIn(object, function(value, key, object) {
+        if (isFunc
+              ? !callback(value, key, object)
+              : indexOf(props, key, 1) < 0
+            ) {
+          result[key] = value;
+        }
+      });
+      return result;
+    }
+
+    /**
+     * Creates a two dimensional array of the given object's key-value pairs,
+     * i.e. `[[key1, value1], [key2, value2]]`.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Object} object The object to inspect.
+     * @returns {Array} Returns new array of key-value pairs.
+     * @example
+     *
+     * _.pairs({ 'moe': 30, 'larry': 40 });
+     * // => [['moe', 30], ['larry', 40]] (order is not guaranteed)
+     */
+    function pairs(object) {
+      var index = -1,
+          props = keys(object),
+          length = props.length,
+          result = Array(length);
+
+      while (++index < length) {
+        var key = props[index];
+        result[index] = [key, object[key]];
+      }
+      return result;
+    }
+
+    /**
+     * Converts the given `value` into an integer of the specified `radix`.
+     *
+     * Note: This method avoids differences in native ES3 and ES5 `parseInt`
+     * implementations. See http://es5.github.com/#E.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} value The value to parse.
+     * @returns {Number} Returns the new integer value.
+     * @example
+     *
+     * _.parseInt('08');
+     * // => 8
+     */
+    var parseInt = nativeParseInt('08') == 8 ? nativeParseInt : function(value, radix) {
+      // Firefox and Opera still follow the ES3 specified implementation of `parseInt`
+      return nativeParseInt(isString(value) ? value.replace(/^0+(?=.$)/, '') : value, radix || 0);
+    };
+
+    /**
+     * Creates a shallow clone of `object` composed of the specified properties.
+     * Property names may be specified as individual arguments or as arrays of property
+     * names. If `callback` is passed, it will be executed for each property in the
+     * `object`, picking the properties `callback` returns truthy for. The `callback`
+     * is bound to `thisArg` and invoked with three arguments; (value, key, object).
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Object} object The source object.
+     * @param {Array|Function|String} callback|[prop1, prop2, ...] The function called
+     *  per iteration or properties to pick, either as individual arguments or arrays.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Object} Returns an object composed of the picked properties.
+     * @example
+     *
+     * _.pick({ 'name': 'moe', '_userid': 'moe1' }, 'name');
+     * // => { 'name': 'moe' }
+     *
+     * _.pick({ 'name': 'moe', '_userid': 'moe1' }, function(value, key) {
+     *   return key.charAt(0) != '_';
+     * });
+     * // => { 'name': 'moe' }
+     */
+    function pick(object, callback, thisArg) {
+      var result = {};
+      if (typeof callback != 'function') {
+        var index = 0,
+            props = concat.apply(arrayRef, arguments),
+            length = isObject(object) ? props.length : 0;
+
+        while (++index < length) {
+          var key = props[index];
+          if (key in object) {
+            result[key] = object[key];
+          }
+        }
+      } else {
+        callback = createCallback(callback, thisArg);
+        forIn(object, function(value, key, object) {
+          if (callback(value, key, object)) {
+            result[key] = value;
+          }
+        });
+      }
+      return result;
+    }
+
+    /**
+     * Creates an array composed of the own enumerable property values of `object`.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Object} object The object to inspect.
+     * @returns {Array} Returns a new array of property values.
+     * @example
+     *
+     * _.values({ 'one': 1, 'two': 2, 'three': 3 });
+     * // => [1, 2, 3]
+     */
+    function values(object) {
+      var index = -1,
+          props = keys(object),
+          length = props.length,
+          result = Array(length);
+
+      while (++index < length) {
+        result[index] = object[props[index]];
+      }
+      return result;
+    }
+
+    /*--------------------------------------------------------------------------*/
+
+    /**
+     * Creates an array of elements from the specified indexes, or keys, of the
+     * `collection`. Indexes may be specified as individual arguments or as arrays
+     * of indexes.
+     *
+     * @static
+     * @memberOf _
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Array|Number|String} [index1, index2, ...] The indexes of
+     *  `collection` to retrieve, either as individual arguments or arrays.
+     * @returns {Array} Returns a new array of elements corresponding to the
+     *  provided indexes.
+     * @example
+     *
+     * _.at(['a', 'b', 'c', 'd', 'e'], [0, 2, 4]);
+     * // => ['a', 'c', 'e']
+     *
+     * _.at(['moe', 'larry', 'curly'], 0, 2);
+     * // => ['moe', 'curly']
+     */
+    function at(collection) {
+      var index = -1,
+          props = concat.apply(arrayRef, slice(arguments, 1)),
+          length = props.length,
+          result = Array(length);
+
+      while(++index < length) {
+        result[index] = collection[props[index]];
+      }
+      return result;
+    }
+
+    /**
+     * Checks if a given `target` element is present in a `collection` using strict
+     * equality for comparisons, i.e. `===`. If `fromIndex` is negative, it is used
+     * as the offset from the end of the collection.
+     *
+     * @static
+     * @memberOf _
+     * @alias include
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Mixed} target The value to check for.
+     * @param {Number} [fromIndex=0] The index to search from.
+     * @returns {Boolean} Returns `true` if the `target` element is found, else `false`.
+     * @example
+     *
+     * _.contains([1, 2, 3], 1);
+     * // => true
+     *
+     * _.contains([1, 2, 3], 1, 2);
+     * // => false
+     *
+     * _.contains({ 'name': 'moe', 'age': 40 }, 'moe');
+     * // => true
+     *
+     * _.contains('curly', 'ur');
+     * // => true
+     */
+    function contains(collection, target, fromIndex) {
+      var index = -1,
+          length = collection ? collection.length : 0,
+          result = false;
+
+      fromIndex = (fromIndex < 0 ? nativeMax(0, length + fromIndex) : fromIndex) || 0;
+      if (typeof length == 'number') {
+        result = (isString(collection)
+          ? collection.indexOf(target, fromIndex)
+          : indexOf(collection, target, fromIndex)
+        ) > -1;
+      } else {
+        each(collection, function(value) {
+          if (++index >= fromIndex) {
+            return !(result = value === target);
+          }
+        });
+      }
+      return result;
+    }
+
+    /**
+     * Creates an object composed of keys returned from running each element of the
+     * `collection` through the given `callback`. The corresponding value of each key
+     * is the number of times the key was returned by the `callback`. The `callback`
+     * is bound to `thisArg` and invoked with three arguments; (value, index|key, collection).
+     *
+     * If a property name is passed for `callback`, the created "_.pluck" style
+     * callback will return the property value of the given element.
+     *
+     * If an object is passed for `callback`, the created "_.where" style callback
+     * will return `true` for elements that have the propeties of the given object,
+     * else `false`.
+     *
+     * @static
+     * @memberOf _
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Function|Object|String} [callback=identity] The function called per
+     *  iteration. If a property name or object is passed, it will be used to create
+     *  a "_.pluck" or "_.where" style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Object} Returns the composed aggregate object.
+     * @example
+     *
+     * _.countBy([4.3, 6.1, 6.4], function(num) { return Math.floor(num); });
+     * // => { '4': 1, '6': 2 }
+     *
+     * _.countBy([4.3, 6.1, 6.4], function(num) { return this.floor(num); }, Math);
+     * // => { '4': 1, '6': 2 }
+     *
+     * _.countBy(['one', 'two', 'three'], 'length');
+     * // => { '3': 2, '5': 1 }
+     */
+    function countBy(collection, callback, thisArg) {
+      var result = {};
+      callback = createCallback(callback, thisArg);
+
+      forEach(collection, function(value, key, collection) {
+        key = callback(value, key, collection) + '';
+        (hasOwnProperty.call(result, key) ? result[key]++ : result[key] = 1);
+      });
+      return result;
+    }
+
+    /**
+     * Checks if the `callback` returns a truthy value for **all** elements of a
+     * `collection`. The `callback` is bound to `thisArg` and invoked with three
+     * arguments; (value, index|key, collection).
+     *
+     * If a property name is passed for `callback`, the created "_.pluck" style
+     * callback will return the property value of the given element.
+     *
+     * If an object is passed for `callback`, the created "_.where" style callback
+     * will return `true` for elements that have the propeties of the given object,
+     * else `false`.
+     *
+     * @static
+     * @memberOf _
+     * @alias all
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Function|Object|String} [callback=identity] The function called per
+     *  iteration. If a property name or object is passed, it will be used to create
+     *  a "_.pluck" or "_.where" style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Boolean} Returns `true` if all elements pass the callback check,
+     *  else `false`.
+     * @example
+     *
+     * _.every([true, 1, null, 'yes'], Boolean);
+     * // => false
+     *
+     * var stooges = [
+     *   { 'name': 'moe', 'age': 40 },
+     *   { 'name': 'larry', 'age': 50 }
+     * ];
+     *
+     * // using "_.pluck" callback shorthand
+     * _.every(stooges, 'age');
+     * // => true
+     *
+     * // using "_.where" callback shorthand
+     * _.every(stooges, { 'age': 50 });
+     * // => false
+     */
+    function every(collection, callback, thisArg) {
+      var result = true;
+      callback = createCallback(callback, thisArg);
+
+      if (isArray(collection)) {
+        var index = -1,
+            length = collection.length;
+
+        while (++index < length) {
+          if (!(result = !!callback(collection[index], index, collection))) {
+            break;
+          }
+        }
+      } else {
+        each(collection, function(value, index, collection) {
+          return (result = !!callback(value, index, collection));
+        });
+      }
+      return result;
+    }
+
+    /**
+     * Examines each element in a `collection`, returning an array of all elements
+     * the `callback` returns truthy for. The `callback` is bound to `thisArg` and
+     * invoked with three arguments; (value, index|key, collection).
+     *
+     * If a property name is passed for `callback`, the created "_.pluck" style
+     * callback will return the property value of the given element.
+     *
+     * If an object is passed for `callback`, the created "_.where" style callback
+     * will return `true` for elements that have the propeties of the given object,
+     * else `false`.
+     *
+     * @static
+     * @memberOf _
+     * @alias select
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Function|Object|String} [callback=identity] The function called per
+     *  iteration. If a property name or object is passed, it will be used to create
+     *  a "_.pluck" or "_.where" style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Array} Returns a new array of elements that passed the callback check.
+     * @example
+     *
+     * var evens = _.filter([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; });
+     * // => [2, 4, 6]
+     *
+     * var food = [
+     *   { 'name': 'apple',  'organic': false, 'type': 'fruit' },
+     *   { 'name': 'carrot', 'organic': true,  'type': 'vegetable' }
+     * ];
+     *
+     * // using "_.pluck" callback shorthand
+     * _.filter(food, 'organic');
+     * // => [{ 'name': 'carrot', 'organic': true, 'type': 'vegetable' }]
+     *
+     * // using "_.where" callback shorthand
+     * _.filter(food, { 'type': 'fruit' });
+     * // => [{ 'name': 'apple', 'organic': false, 'type': 'fruit' }]
+     */
+    function filter(collection, callback, thisArg) {
+      var result = [];
+      callback = createCallback(callback, thisArg);
+
+      if (isArray(collection)) {
+        var index = -1,
+            length = collection.length;
+
+        while (++index < length) {
+          var value = collection[index];
+          if (callback(value, index, collection)) {
+            result.push(value);
+          }
+        }
+      } else {
+        each(collection, function(value, index, collection) {
+          if (callback(value, index, collection)) {
+            result.push(value);
+          }
+        });
+      }
+      return result;
+    }
+
+    /**
+     * Examines each element in a `collection`, returning the first that the `callback`
+     * returns truthy for. The `callback` is bound to `thisArg` and invoked with three
+     * arguments; (value, index|key, collection).
+     *
+     * If a property name is passed for `callback`, the created "_.pluck" style
+     * callback will return the property value of the given element.
+     *
+     * If an object is passed for `callback`, the created "_.where" style callback
+     * will return `true` for elements that have the propeties of the given object,
+     * else `false`.
+     *
+     * @static
+     * @memberOf _
+     * @alias detect
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Function|Object|String} [callback=identity] The function called per
+     *  iteration. If a property name or object is passed, it will be used to create
+     *  a "_.pluck" or "_.where" style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Mixed} Returns the element that passed the callback check,
+     *  else `undefined`.
+     * @example
+     *
+     * var even = _.find([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; });
+     * // => 2
+     *
+     * var food = [
+     *   { 'name': 'apple',  'organic': false, 'type': 'fruit' },
+     *   { 'name': 'banana', 'organic': true,  'type': 'fruit' },
+     *   { 'name': 'beet',   'organic': false, 'type': 'vegetable' },
+     *   { 'name': 'carrot', 'organic': true,  'type': 'vegetable' }
+     * ];
+     *
+     * // using "_.where" callback shorthand
+     * var veggie = _.find(food, { 'type': 'vegetable' });
+     * // => { 'name': 'beet', 'organic': false, 'type': 'vegetable' }
+     *
+     * // using "_.pluck" callback shorthand
+     * var healthy = _.find(food, 'organic');
+     * // => { 'name': 'banana', 'organic': true, 'type': 'fruit' }
+     */
+    function find(collection, callback, thisArg) {
+      var result;
+      callback = createCallback(callback, thisArg);
+
+      forEach(collection, function(value, index, collection) {
+        if (callback(value, index, collection)) {
+          result = value;
+          return false;
+        }
+      });
+      return result;
+    }
+
+    /**
+     * Iterates over a `collection`, executing the `callback` for each element in
+     * the `collection`. The `callback` is bound to `thisArg` and invoked with three
+     * arguments; (value, index|key, collection). Callbacks may exit iteration early
+     * by explicitly returning `false`.
+     *
+     * @static
+     * @memberOf _
+     * @alias each
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Function} [callback=identity] The function called per iteration.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Array|Object|String} Returns `collection`.
+     * @example
+     *
+     * _([1, 2, 3]).forEach(alert).join(',');
+     * // => alerts each number and returns '1,2,3'
+     *
+     * _.forEach({ 'one': 1, 'two': 2, 'three': 3 }, alert);
+     * // => alerts each number value (order is not guaranteed)
+     */
+    function forEach(collection, callback, thisArg) {
+      if (callback && typeof thisArg == 'undefined' && isArray(collection)) {
+        var index = -1,
+            length = collection.length;
+
+        while (++index < length) {
+          if (callback(collection[index], index, collection) === false) {
+            break;
+          }
+        }
+      } else {
+        each(collection, callback, thisArg);
+      }
+      return collection;
+    }
+
+    /**
+     * Creates an object composed of keys returned from running each element of the
+     * `collection` through the `callback`. The corresponding value of each key is
+     * an array of elements passed to `callback` that returned the key. The `callback`
+     * is bound to `thisArg` and invoked with three arguments; (value, index|key, collection).
+     *
+     * If a property name is passed for `callback`, the created "_.pluck" style
+     * callback will return the property value of the given element.
+     *
+     * If an object is passed for `callback`, the created "_.where" style callback
+     * will return `true` for elements that have the propeties of the given object,
+     * else `false`
+     *
+     * @static
+     * @memberOf _
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Function|Object|String} [callback=identity] The function called per
+     *  iteration. If a property name or object is passed, it will be used to create
+     *  a "_.pluck" or "_.where" style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Object} Returns the composed aggregate object.
+     * @example
+     *
+     * _.groupBy([4.2, 6.1, 6.4], function(num) { return Math.floor(num); });
+     * // => { '4': [4.2], '6': [6.1, 6.4] }
+     *
+     * _.groupBy([4.2, 6.1, 6.4], function(num) { return this.floor(num); }, Math);
+     * // => { '4': [4.2], '6': [6.1, 6.4] }
+     *
+     * // using "_.pluck" callback shorthand
+     * _.groupBy(['one', 'two', 'three'], 'length');
+     * // => { '3': ['one', 'two'], '5': ['three'] }
+     */
+    function groupBy(collection, callback, thisArg) {
+      var result = {};
+      callback = createCallback(callback, thisArg);
+
+      forEach(collection, function(value, key, collection) {
+        key = callback(value, key, collection) + '';
+        (hasOwnProperty.call(result, key) ? result[key] : result[key] = []).push(value);
+      });
+      return result;
+    }
+
+    /**
+     * Invokes the method named by `methodName` on each element in the `collection`,
+     * returning an array of the results of each invoked method. Additional arguments
+     * will be passed to each invoked method. If `methodName` is a function, it will
+     * be invoked for, and `this` bound to, each element in the `collection`.
+     *
+     * @static
+     * @memberOf _
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Function|String} methodName The name of the method to invoke or
+     *  the function invoked per iteration.
+     * @param {Mixed} [arg1, arg2, ...] Arguments to invoke the method with.
+     * @returns {Array} Returns a new array of the results of each invoked method.
+     * @example
+     *
+     * _.invoke([[5, 1, 7], [3, 2, 1]], 'sort');
+     * // => [[1, 5, 7], [1, 2, 3]]
+     *
+     * _.invoke([123, 456], String.prototype.split, '');
+     * // => [['1', '2', '3'], ['4', '5', '6']]
+     */
+    function invoke(collection, methodName) {
+      var args = slice(arguments, 2),
+          index = -1,
+          isFunc = typeof methodName == 'function',
+          length = collection ? collection.length : 0,
+          result = Array(typeof length == 'number' ? length : 0);
+
+      forEach(collection, function(value) {
+        result[++index] = (isFunc ? methodName : value[methodName]).apply(value, args);
+      });
+      return result;
+    }
+
+    /**
+     * Creates an array of values by running each element in the `collection`
+     * through the `callback`. The `callback` is bound to `thisArg` and invoked with
+     * three arguments; (value, index|key, collection).
+     *
+     * If a property name is passed for `callback`, the created "_.pluck" style
+     * callback will return the property value of the given element.
+     *
+     * If an object is passed for `callback`, the created "_.where" style callback
+     * will return `true` for elements that have the propeties of the given object,
+     * else `false`.
+     *
+     * @static
+     * @memberOf _
+     * @alias collect
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Function|Object|String} [callback=identity] The function called per
+     *  iteration. If a property name or object is passed, it will be used to create
+     *  a "_.pluck" or "_.where" style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Array} Returns a new array of the results of each `callback` execution.
+     * @example
+     *
+     * _.map([1, 2, 3], function(num) { return num * 3; });
+     * // => [3, 6, 9]
+     *
+     * _.map({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { return num * 3; });
+     * // => [3, 6, 9] (order is not guaranteed)
+     *
+     * var stooges = [
+     *   { 'name': 'moe', 'age': 40 },
+     *   { 'name': 'larry', 'age': 50 }
+     * ];
+     *
+     * // using "_.pluck" callback shorthand
+     * _.map(stooges, 'name');
+     * // => ['moe', 'larry']
+     */
+    function map(collection, callback, thisArg) {
+      var index = -1,
+          length = collection ? collection.length : 0,
+          result = Array(typeof length == 'number' ? length : 0);
+
+      callback = createCallback(callback, thisArg);
+      if (isArray(collection)) {
+        while (++index < length) {
+          result[index] = callback(collection[index], index, collection);
+        }
+      } else {
+        each(collection, function(value, key, collection) {
+          result[++index] = callback(value, key, collection);
+        });
+      }
+      return result;
+    }
+
+    /**
+     * Retrieves the maximum value of an `array`. If `callback` is passed,
+     * it will be executed for each value in the `array` to generate the
+     * criterion by which the value is ranked. The `callback` is bound to
+     * `thisArg` and invoked with three arguments; (value, index, collection).
+     *
+     * If a property name is passed for `callback`, the created "_.pluck" style
+     * callback will return the property value of the given element.
+     *
+     * If an object is passed for `callback`, the created "_.where" style callback
+     * will return `true` for elements that have the propeties of the given object,
+     * else `false`.
+     *
+     * @static
+     * @memberOf _
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Function|Object|String} [callback=identity] The function called per
+     *  iteration. If a property name or object is passed, it will be used to create
+     *  a "_.pluck" or "_.where" style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Mixed} Returns the maximum value.
+     * @example
+     *
+     * _.max([4, 2, 8, 6]);
+     * // => 8
+     *
+     * var stooges = [
+     *   { 'name': 'moe', 'age': 40 },
+     *   { 'name': 'larry', 'age': 50 }
+     * ];
+     *
+     * _.max(stooges, function(stooge) { return stooge.age; });
+     * // => { 'name': 'larry', 'age': 50 };
+     *
+     * // using "_.pluck" callback shorthand
+     * _.max(stooges, 'age');
+     * // => { 'name': 'larry', 'age': 50 };
+     */
+    function max(collection, callback, thisArg) {
+      var computed = -Infinity,
+          result = computed;
+
+      if (!callback && isArray(collection)) {
+        var index = -1,
+            length = collection.length;
+
+        while (++index < length) {
+          var value = collection[index];
+          if (value > result) {
+            result = value;
+          }
+        }
+      } else {
+        callback = !callback && isString(collection)
+          ? charAtCallback
+          : createCallback(callback, thisArg);
+
+        each(collection, function(value, index, collection) {
+          var current = callback(value, index, collection);
+          if (current > computed) {
+            computed = current;
+            result = value;
+          }
+        });
+      }
+      return result;
+    }
+
+    /**
+     * Retrieves the minimum value of an `array`. If `callback` is passed,
+     * it will be executed for each value in the `array` to generate the
+     * criterion by which the value is ranked. The `callback` is bound to `thisArg`
+     * and invoked with three arguments; (value, index, collection).
+     *
+     * If a property name is passed for `callback`, the created "_.pluck" style
+     * callback will return the property value of the given element.
+     *
+     * If an object is passed for `callback`, the created "_.where" style callback
+     * will return `true` for elements that have the propeties of the given object,
+     * else `false`.
+     *
+     * @static
+     * @memberOf _
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Function|Object|String} [callback=identity] The function called per
+     *  iteration. If a property name or object is passed, it will be used to create
+     *  a "_.pluck" or "_.where" style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Mixed} Returns the minimum value.
+     * @example
+     *
+     * _.min([4, 2, 8, 6]);
+     * // => 2
+     *
+     * var stooges = [
+     *   { 'name': 'moe', 'age': 40 },
+     *   { 'name': 'larry', 'age': 50 }
+     * ];
+     *
+     * _.min(stooges, function(stooge) { return stooge.age; });
+     * // => { 'name': 'moe', 'age': 40 };
+     *
+     * // using "_.pluck" callback shorthand
+     * _.min(stooges, 'age');
+     * // => { 'name': 'moe', 'age': 40 };
+     */
+    function min(collection, callback, thisArg) {
+      var computed = Infinity,
+          result = computed;
+
+      if (!callback && isArray(collection)) {
+        var index = -1,
+            length = collection.length;
+
+        while (++index < length) {
+          var value = collection[index];
+          if (value < result) {
+            result = value;
+          }
+        }
+      } else {
+        callback = !callback && isString(collection)
+          ? charAtCallback
+          : createCallback(callback, thisArg);
+
+        each(collection, function(value, index, collection) {
+          var current = callback(value, index, collection);
+          if (current < computed) {
+            computed = current;
+            result = value;
+          }
+        });
+      }
+      return result;
+    }
+
+    /**
+     * Retrieves the value of a specified property from all elements in the `collection`.
+     *
+     * @static
+     * @memberOf _
+     * @type Function
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {String} property The property to pluck.
+     * @returns {Array} Returns a new array of property values.
+     * @example
+     *
+     * var stooges = [
+     *   { 'name': 'moe', 'age': 40 },
+     *   { 'name': 'larry', 'age': 50 }
+     * ];
+     *
+     * _.pluck(stooges, 'name');
+     * // => ['moe', 'larry']
+     */
+    var pluck = map;
+
+    /**
+     * Reduces a `collection` to a value that is the accumulated result of running
+     * each element in the `collection` through the `callback`, where each successive
+     * `callback` execution consumes the return value of the previous execution.
+     * If `accumulator` is not passed, the first element of the `collection` will be
+     * used as the initial `accumulator` value. The `callback` is bound to `thisArg`
+     * and invoked with four arguments; (accumulator, value, index|key, collection).
+     *
+     * @static
+     * @memberOf _
+     * @alias foldl, inject
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Function} [callback=identity] The function called per iteration.
+     * @param {Mixed} [accumulator] Initial value of the accumulator.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Mixed} Returns the accumulated value.
+     * @example
+     *
+     * var sum = _.reduce([1, 2, 3], function(sum, num) {
+     *   return sum + num;
+     * });
+     * // => 6
+     *
+     * var mapped = _.reduce({ 'a': 1, 'b': 2, 'c': 3 }, function(result, num, key) {
+     *   result[key] = num * 3;
+     *   return result;
+     * }, {});
+     * // => { 'a': 3, 'b': 6, 'c': 9 }
+     */
+    function reduce(collection, callback, accumulator, thisArg) {
+      var noaccum = arguments.length < 3;
+      callback = createCallback(callback, thisArg, 4);
+
+      if (isArray(collection)) {
+        var index = -1,
+            length = collection.length;
+
+        if (noaccum) {
+          accumulator = collection[++index];
+        }
+        while (++index < length) {
+          accumulator = callback(accumulator, collection[index], index, collection);
+        }
+      } else {
+        each(collection, function(value, index, collection) {
+          accumulator = noaccum
+            ? (noaccum = false, value)
+            : callback(accumulator, value, index, collection)
+        });
+      }
+      return accumulator;
+    }
+
+    /**
+     * This method is similar to `_.reduce`, except that it iterates over a
+     * `collection` from right to left.
+     *
+     * @static
+     * @memberOf _
+     * @alias foldr
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Function} [callback=identity] The function called per iteration.
+     * @param {Mixed} [accumulator] Initial value of the accumulator.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Mixed} Returns the accumulated value.
+     * @example
+     *
+     * var list = [[0, 1], [2, 3], [4, 5]];
+     * var flat = _.reduceRight(list, function(a, b) { return a.concat(b); }, []);
+     * // => [4, 5, 2, 3, 0, 1]
+     */
+    function reduceRight(collection, callback, accumulator, thisArg) {
+      var iterable = collection,
+          length = collection ? collection.length : 0,
+          noaccum = arguments.length < 3;
+
+      if (typeof length != 'number') {
+        var props = keys(collection);
+        length = props.length;
+      }
+      callback = createCallback(callback, thisArg, 4);
+      forEach(collection, function(value, index, collection) {
+        index = props ? props[--length] : --length;
+        accumulator = noaccum
+          ? (noaccum = false, iterable[index])
+          : callback(accumulator, iterable[index], index, collection);
+      });
+      return accumulator;
+    }
+
+    /**
+     * The opposite of `_.filter`, this method returns the elements of a
+     * `collection` that `callback` does **not** return truthy for.
+     *
+     * If a property name is passed for `callback`, the created "_.pluck" style
+     * callback will return the property value of the given element.
+     *
+     * If an object is passed for `callback`, the created "_.where" style callback
+     * will return `true` for elements that have the propeties of the given object,
+     * else `false`.
+     *
+     * @static
+     * @memberOf _
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Function|Object|String} [callback=identity] The function called per
+     *  iteration. If a property name or object is passed, it will be used to create
+     *  a "_.pluck" or "_.where" style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Array} Returns a new array of elements that did **not** pass the
+     *  callback check.
+     * @example
+     *
+     * var odds = _.reject([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; });
+     * // => [1, 3, 5]
+     *
+     * var food = [
+     *   { 'name': 'apple',  'organic': false, 'type': 'fruit' },
+     *   { 'name': 'carrot', 'organic': true,  'type': 'vegetable' }
+     * ];
+     *
+     * // using "_.pluck" callback shorthand
+     * _.reject(food, 'organic');
+     * // => [{ 'name': 'apple', 'organic': false, 'type': 'fruit' }]
+     *
+     * // using "_.where" callback shorthand
+     * _.reject(food, { 'type': 'fruit' });
+     * // => [{ 'name': 'carrot', 'organic': true, 'type': 'vegetable' }]
+     */
+    function reject(collection, callback, thisArg) {
+      callback = createCallback(callback, thisArg);
+      return filter(collection, function(value, index, collection) {
+        return !callback(value, index, collection);
+      });
+    }
+
+    /**
+     * Creates an array of shuffled `array` values, using a version of the
+     * Fisher-Yates shuffle. See http://en.wikipedia.org/wiki/Fisher-Yates_shuffle.
+     *
+     * @static
+     * @memberOf _
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to shuffle.
+     * @returns {Array} Returns a new shuffled collection.
+     * @example
+     *
+     * _.shuffle([1, 2, 3, 4, 5, 6]);
+     * // => [4, 1, 6, 3, 5, 2]
+     */
+    function shuffle(collection) {
+      var index = -1,
+          length = collection ? collection.length : 0,
+          result = Array(typeof length == 'number' ? length : 0);
+
+      forEach(collection, function(value) {
+        var rand = floor(nativeRandom() * (++index + 1));
+        result[index] = result[rand];
+        result[rand] = value;
+      });
+      return result;
+    }
+
+    /**
+     * Gets the size of the `collection` by returning `collection.length` for arrays
+     * and array-like objects or the number of own enumerable properties for objects.
+     *
+     * @static
+     * @memberOf _
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to inspect.
+     * @returns {Number} Returns `collection.length` or number of own enumerable properties.
+     * @example
+     *
+     * _.size([1, 2]);
+     * // => 2
+     *
+     * _.size({ 'one': 1, 'two': 2, 'three': 3 });
+     * // => 3
+     *
+     * _.size('curly');
+     * // => 5
+     */
+    function size(collection) {
+      var length = collection ? collection.length : 0;
+      return typeof length == 'number' ? length : keys(collection).length;
+    }
+
+    /**
+     * Checks if the `callback` returns a truthy value for **any** element of a
+     * `collection`. The function returns as soon as it finds passing value, and
+     * does not iterate over the entire `collection`. The `callback` is bound to
+     * `thisArg` and invoked with three arguments; (value, index|key, collection).
+     *
+     * If a property name is passed for `callback`, the created "_.pluck" style
+     * callback will return the property value of the given element.
+     *
+     * If an object is passed for `callback`, the created "_.where" style callback
+     * will return `true` for elements that have the propeties of the given object,
+     * else `false`.
+     *
+     * @static
+     * @memberOf _
+     * @alias any
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Function|Object|String} [callback=identity] The function called per
+     *  iteration. If a property name or object is passed, it will be used to create
+     *  a "_.pluck" or "_.where" style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Boolean} Returns `true` if any element passes the callback check,
+     *  else `false`.
+     * @example
+     *
+     * _.some([null, 0, 'yes', false], Boolean);
+     * // => true
+     *
+     * var food = [
+     *   { 'name': 'apple',  'organic': false, 'type': 'fruit' },
+     *   { 'name': 'carrot', 'organic': true,  'type': 'vegetable' }
+     * ];
+     *
+     * // using "_.pluck" callback shorthand
+     * _.some(food, 'organic');
+     * // => true
+     *
+     * // using "_.where" callback shorthand
+     * _.some(food, { 'type': 'meat' });
+     * // => false
+     */
+    function some(collection, callback, thisArg) {
+      var result;
+      callback = createCallback(callback, thisArg);
+
+      if (isArray(collection)) {
+        var index = -1,
+            length = collection.length;
+
+        while (++index < length) {
+          if ((result = callback(collection[index], index, collection))) {
+            break;
+          }
+        }
+      } else {
+        each(collection, function(value, index, collection) {
+          return !(result = callback(value, index, collection));
+        });
+      }
+      return !!result;
+    }
+
+    /**
+     * Creates an array of elements, sorted in ascending order by the results of
+     * running each element in the `collection` through the `callback`. This method
+     * performs a stable sort, that is, it will preserve the original sort order of
+     * equal elements. The `callback` is bound to `thisArg` and invoked with three
+     * arguments; (value, index|key, collection).
+     *
+     * If a property name is passed for `callback`, the created "_.pluck" style
+     * callback will return the property value of the given element.
+     *
+     * If an object is passed for `callback`, the created "_.where" style callback
+     * will return `true` for elements that have the propeties of the given object,
+     * else `false`.
+     *
+     * @static
+     * @memberOf _
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Function|Object|String} [callback=identity] The function called per
+     *  iteration. If a property name or object is passed, it will be used to create
+     *  a "_.pluck" or "_.where" style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Array} Returns a new array of sorted elements.
+     * @example
+     *
+     * _.sortBy([1, 2, 3], function(num) { return Math.sin(num); });
+     * // => [3, 1, 2]
+     *
+     * _.sortBy([1, 2, 3], function(num) { return this.sin(num); }, Math);
+     * // => [3, 1, 2]
+     *
+     * // using "_.pluck" callback shorthand
+     * _.sortBy(['banana', 'strawberry', 'apple'], 'length');
+     * // => ['apple', 'banana', 'strawberry']
+     */
+    function sortBy(collection, callback, thisArg) {
+      var index = -1,
+          length = collection ? collection.length : 0,
+          result = Array(typeof length == 'number' ? length : 0);
+
+      callback = createCallback(callback, thisArg);
+      forEach(collection, function(value, key, collection) {
+        result[++index] = {
+          'criteria': callback(value, key, collection),
+          'index': index,
+          'value': value
+        };
+      });
+
+      length = result.length;
+      result.sort(compareAscending);
+      while (length--) {
+        result[length] = result[length].value;
+      }
+      return result;
+    }
+
+    /**
+     * Converts the `collection` to an array.
+     *
+     * @static
+     * @memberOf _
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to convert.
+     * @returns {Array} Returns the new converted array.
+     * @example
+     *
+     * (function() { return _.toArray(arguments).slice(1); })(1, 2, 3, 4);
+     * // => [2, 3, 4]
+     */
+    function toArray(collection) {
+      if (collection && typeof collection.length == 'number') {
+        return  slice(collection);
+      }
+      return values(collection);
+    }
+
+    /**
+     * Examines each element in a `collection`, returning an array of all elements
+     * that have the given `properties`. When checking `properties`, this method
+     * performs a deep comparison between values to determine if they are equivalent
+     * to each other.
+     *
+     * @static
+     * @memberOf _
+     * @type Function
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Object} properties The object of property values to filter by.
+     * @returns {Array} Returns a new array of elements that have the given `properties`.
+     * @example
+     *
+     * var stooges = [
+     *   { 'name': 'moe', 'age': 40 },
+     *   { 'name': 'larry', 'age': 50 }
+     * ];
+     *
+     * _.where(stooges, { 'age': 40 });
+     * // => [{ 'name': 'moe', 'age': 40 }]
+     */
+    var where = filter;
+
+    /*--------------------------------------------------------------------------*/
+
+    /**
+     * Creates an array with all falsey values of `array` removed. The values
+     * `false`, `null`, `0`, `""`, `undefined` and `NaN` are all falsey.
+     *
+     * @static
+     * @memberOf _
+     * @category Arrays
+     * @param {Array} array The array to compact.
+     * @returns {Array} Returns a new filtered array.
+     * @example
+     *
+     * _.compact([0, 1, false, 2, '', 3]);
+     * // => [1, 2, 3]
+     */
+    function compact(array) {
+      var index = -1,
+          length = array ? array.length : 0,
+          result = [];
+
+      while (++index < length) {
+        var value = array[index];
+        if (value) {
+          result.push(value);
+        }
+      }
+      return result;
+    }
+
+    /**
+     * Creates an array of `array` elements not present in the other arrays
+     * using strict equality for comparisons, i.e. `===`.
+     *
+     * @static
+     * @memberOf _
+     * @category Arrays
+     * @param {Array} array The array to process.
+     * @param {Array} [array1, array2, ...] Arrays to check.
+     * @returns {Array} Returns a new array of `array` elements not present in the
+     *  other arrays.
+     * @example
+     *
+     * _.difference([1, 2, 3, 4, 5], [5, 2, 10]);
+     * // => [1, 3, 4]
+     */
+    function difference(array) {
+      var index = -1,
+          length = array ? array.length : 0,
+          flattened = concat.apply(arrayRef, arguments),
+          contains = cachedContains(flattened, length),
+          result = [];
+
+      while (++index < length) {
+        var value = array[index];
+        if (!contains(value)) {
+          result.push(value);
+        }
+      }
+      return result;
+    }
+
+    /**
+     * Gets the first element of the `array`. If a number `n` is passed, the first
+     * `n` elements of the `array` are returned. If a `callback` function is passed,
+     * elements at the beginning of the array are returned as long as the `callback`
+     * returns truthy. The `callback` is bound to `thisArg` and invoked with three
+     * arguments; (value, index, array).
+     *
+     * If a property name is passed for `callback`, the created "_.pluck" style
+     * callback will return the property value of the given element.
+     *
+     * If an object is passed for `callback`, the created "_.where" style callback
+     * will return `true` for elements that have the propeties of the given object,
+     * else `false`.
+     *
+     * @static
+     * @memberOf _
+     * @alias head, take
+     * @category Arrays
+     * @param {Array} array The array to query.
+     * @param {Function|Object|Number|String} [callback|n] The function called
+     *  per element or the number of elements to return. If a property name or
+     *  object is passed, it will be used to create a "_.pluck" or "_.where"
+     *  style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Mixed} Returns the first element(s) of `array`.
+     * @example
+     *
+     * _.first([1, 2, 3]);
+     * // => 1
+     *
+     * _.first([1, 2, 3], 2);
+     * // => [1, 2]
+     *
+     * _.first([1, 2, 3], function(num) {
+     *   return num < 3;
+     * });
+     * // => [1, 2]
+     *
+     * var food = [
+     *   { 'name': 'banana', 'organic': true },
+     *   { 'name': 'beet',   'organic': false },
+     * ];
+     *
+     * // using "_.pluck" callback shorthand
+     * _.first(food, 'organic');
+     * // => [{ 'name': 'banana', 'organic': true }]
+     *
+     * var food = [
+     *   { 'name': 'apple',  'type': 'fruit' },
+     *   { 'name': 'banana', 'type': 'fruit' },
+     *   { 'name': 'beet',   'type': 'vegetable' }
+     * ];
+     *
+     * // using "_.where" callback shorthand
+     * _.first(food, { 'type': 'fruit' });
+     * // => [{ 'name': 'apple', 'type': 'fruit' }, { 'name': 'banana', 'type': 'fruit' }]
+     */
+    function first(array, callback, thisArg) {
+      if (array) {
+        var n = 0,
+            length = array.length;
+
+        if (typeof callback != 'number' && callback != null) {
+          var index = -1;
+          callback = createCallback(callback, thisArg);
+          while (++index < length && callback(array[index], index, array)) {
+            n++;
+          }
+        } else {
+          n = callback;
+          if (n == null || thisArg) {
+            return array[0];
+          }
+        }
+        return slice(array, 0, nativeMin(nativeMax(0, n), length));
+      }
+    }
+
+    /**
+     * Flattens a nested array (the nesting can be to any depth). If `shallow` is
+     * truthy, `array` will only be flattened a single level.
+     *
+     * @static
+     * @memberOf _
+     * @category Arrays
+     * @param {Array} array The array to compact.
+     * @param {Boolean} shallow A flag to indicate only flattening a single level.
+     * @returns {Array} Returns a new flattened array.
+     * @example
+     *
+     * _.flatten([1, [2], [3, [[4]]]]);
+     * // => [1, 2, 3, 4];
+     *
+     * _.flatten([1, [2], [3, [[4]]]], true);
+     * // => [1, 2, 3, [[4]]];
+     */
+    function flatten(array, shallow) {
+      var index = -1,
+          length = array ? array.length : 0,
+          result = [];
+
+      while (++index < length) {
+        var value = array[index];
+
+        // recursively flatten arrays (susceptible to call stack limits)
+        if (isArray(value)) {
+          push.apply(result, shallow ? value : flatten(value));
+        } else {
+          result.push(value);
+        }
+      }
+      return result;
+    }
+
+    /**
+     * Gets the index at which the first occurrence of `value` is found using
+     * strict equality for comparisons, i.e. `===`. If the `array` is already
+     * sorted, passing `true` for `fromIndex` will run a faster binary search.
+     *
+     * @static
+     * @memberOf _
+     * @category Arrays
+     * @param {Array} array The array to search.
+     * @param {Mixed} value The value to search for.
+     * @param {Boolean|Number} [fromIndex=0] The index to search from or `true` to
+     *  perform a binary search on a sorted `array`.
+     * @returns {Number} Returns the index of the matched value or `-1`.
+     * @example
+     *
+     * _.indexOf([1, 2, 3, 1, 2, 3], 2);
+     * // => 1
+     *
+     * _.indexOf([1, 2, 3, 1, 2, 3], 2, 3);
+     * // => 4
+     *
+     * _.indexOf([1, 1, 2, 2, 3, 3], 2, true);
+     * // => 2
+     */
+    function indexOf(array, value, fromIndex) {
+      var index = -1,
+          length = array ? array.length : 0;
+
+      if (typeof fromIndex == 'number') {
+        index = (fromIndex < 0 ? nativeMax(0, length + fromIndex) : fromIndex || 0) - 1;
+      } else if (fromIndex) {
+        index = sortedIndex(array, value);
+        return array[index] === value ? index : -1;
+      }
+      while (++index < length) {
+        if (array[index] === value) {
+          return index;
+        }
+      }
+      return -1;
+    }
+
+    /**
+     * Gets all but the last element of `array`. If a number `n` is passed, the
+     * last `n` elements are excluded from the result. If a `callback` function
+     * is passed, elements at the end of the array are excluded from the result
+     * as long as the `callback` returns truthy. The `callback` is bound to
+     * `thisArg` and invoked with three arguments; (value, index, array).
+     *
+     * If a property name is passed for `callback`, the created "_.pluck" style
+     * callback will return the property value of the given element.
+     *
+     * If an object is passed for `callback`, the created "_.where" style callback
+     * will return `true` for elements that have the propeties of the given object,
+     * else `false`.
+     *
+     * @static
+     * @memberOf _
+     * @category Arrays
+     * @param {Array} array The array to query.
+     * @param {Function|Object|Number|String} [callback|n=1] The function called
+     *  per element or the number of elements to exclude. If a property name or
+     *  object is passed, it will be used to create a "_.pluck" or "_.where"
+     *  style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Array} Returns a slice of `array`.
+     * @example
+     *
+     * _.initial([1, 2, 3]);
+     * // => [1, 2]
+     *
+     * _.initial([1, 2, 3], 2);
+     * // => [1]
+     *
+     * _.initial([1, 2, 3], function(num) {
+     *   return num > 1;
+     * });
+     * // => [1]
+     *
+     * var food = [
+     *   { 'name': 'beet',   'organic': false },
+     *   { 'name': 'carrot', 'organic': true }
+     * ];
+     *
+     * // using "_.pluck" callback shorthand
+     * _.initial(food, 'organic');
+     * // => [{ 'name': 'beet',   'organic': false }]
+     *
+     * var food = [
+     *   { 'name': 'banana', 'type': 'fruit' },
+     *   { 'name': 'beet',   'type': 'vegetable' },
+     *   { 'name': 'carrot', 'type': 'vegetable' }
+     * ];
+     *
+     * // using "_.where" callback shorthand
+     * _.initial(food, { 'type': 'vegetable' });
+     * // => [{ 'name': 'banana', 'type': 'fruit' }]
+     */
+    function initial(array, callback, thisArg) {
+      if (!array) {
+        return [];
+      }
+      var n = 0,
+          length = array.length;
+
+      if (typeof callback != 'number' && callback != null) {
+        var index = length;
+        callback = createCallback(callback, thisArg);
+        while (index-- && callback(array[index], index, array)) {
+          n++;
+        }
+      } else {
+        n = (callback == null || thisArg) ? 1 : callback || n;
+      }
+      return slice(array, 0, nativeMin(nativeMax(0, length - n), length));
+    }
+
+    /**
+     * Computes the intersection of all the passed-in arrays using strict equality
+     * for comparisons, i.e. `===`.
+     *
+     * @static
+     * @memberOf _
+     * @category Arrays
+     * @param {Array} [array1, array2, ...] Arrays to process.
+     * @returns {Array} Returns a new array of unique elements that are present
+     *  in **all** of the arrays.
+     * @example
+     *
+     * _.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]);
+     * // => [1, 2]
+     */
+    function intersection(array) {
+      var args = arguments,
+          argsLength = args.length,
+          cache = { '0': {} },
+          index = -1,
+          length = array ? array.length : 0,
+          isLarge = length >= 100,
+          result = [],
+          seen = result;
+
+      outer:
+      while (++index < length) {
+        var value = array[index];
+        if (isLarge) {
+          var key = value + '';
+          var inited = hasOwnProperty.call(cache[0], key)
+            ? !(seen = cache[0][key])
+            : (seen = cache[0][key] = []);
+        }
+        if (inited || indexOf(seen, value) < 0) {
+          if (isLarge) {
+            seen.push(value);
+          }
+          var argsIndex = argsLength;
+          while (--argsIndex) {
+            if (!(cache[argsIndex] || (cache[argsIndex] = cachedContains(args[argsIndex], 0, 100)))(value)) {
+              continue outer;
+            }
+          }
+          result.push(value);
+        }
+      }
+      return result;
+    }
+
+    /**
+     * Gets the last element of the `array`. If a number `n` is passed, the
+     * last `n` elements of the `array` are returned. If a `callback` function
+     * is passed, elements at the end of the array are returned as long as the
+     * `callback` returns truthy. The `callback` is bound to `thisArg` and
+     * invoked with three arguments;(value, index, array).
+     *
+     *
+     * If a property name is passed for `callback`, the created "_.pluck" style
+     * callback will return the property value of the given element.
+     *
+     * If an object is passed for `callback`, the created "_.where" style callback
+     * will return `true` for elements that have the propeties of the given object,
+     * else `false`.
+     *
+     * @static
+     * @memberOf _
+     * @category Arrays
+     * @param {Array} array The array to query.
+     * @param {Function|Object|Number|String} [callback|n] The function called
+     *  per element or the number of elements to return. If a property name or
+     *  object is passed, it will be used to create a "_.pluck" or "_.where"
+     *  style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Mixed} Returns the last element(s) of `array`.
+     * @example
+     *
+     * _.last([1, 2, 3]);
+     * // => 3
+     *
+     * _.last([1, 2, 3], 2);
+     * // => [2, 3]
+     *
+     * _.last([1, 2, 3], function(num) {
+     *   return num > 1;
+     * });
+     * // => [2, 3]
+     *
+     * var food = [
+     *   { 'name': 'beet',   'organic': false },
+     *   { 'name': 'carrot', 'organic': true }
+     * ];
+     *
+     * // using "_.pluck" callback shorthand
+     * _.last(food, 'organic');
+     * // => [{ 'name': 'carrot', 'organic': true }]
+     *
+     * var food = [
+     *   { 'name': 'banana', 'type': 'fruit' },
+     *   { 'name': 'beet',   'type': 'vegetable' },
+     *   { 'name': 'carrot', 'type': 'vegetable' }
+     * ];
+     *
+     * // using "_.where" callback shorthand
+     * _.last(food, { 'type': 'vegetable' });
+     * // => [{ 'name': 'beet', 'type': 'vegetable' }, { 'name': 'carrot', 'type': 'vegetable' }]
+     */
+    function last(array, callback, thisArg) {
+      if (array) {
+        var n = 0,
+            length = array.length;
+
+        if (typeof callback != 'number' && callback != null) {
+          var index = length;
+          callback = createCallback(callback, thisArg);
+          while (index-- && callback(array[index], index, array)) {
+            n++;
+          }
+        } else {
+          n = callback;
+          if (n == null || thisArg) {
+            return array[length - 1];
+          }
+        }
+        return slice(array, nativeMax(0, length - n));
+      }
+    }
+
+    /**
+     * Gets the index at which the last occurrence of `value` is found using strict
+     * equality for comparisons, i.e. `===`. If `fromIndex` is negative, it is used
+     * as the offset from the end of the collection.
+     *
+     * @static
+     * @memberOf _
+     * @category Arrays
+     * @param {Array} array The array to search.
+     * @param {Mixed} value The value to search for.
+     * @param {Number} [fromIndex=array.length-1] The index to search from.
+     * @returns {Number} Returns the index of the matched value or `-1`.
+     * @example
+     *
+     * _.lastIndexOf([1, 2, 3, 1, 2, 3], 2);
+     * // => 4
+     *
+     * _.lastIndexOf([1, 2, 3, 1, 2, 3], 2, 3);
+     * // => 1
+     */
+    function lastIndexOf(array, value, fromIndex) {
+      var index = array ? array.length : 0;
+      if (typeof fromIndex == 'number') {
+        index = (fromIndex < 0 ? nativeMax(0, index + fromIndex) : nativeMin(fromIndex, index - 1)) + 1;
+      }
+      while (index--) {
+        if (array[index] === value) {
+          return index;
+        }
+      }
+      return -1;
+    }
+
+    /**
+     * Creates an object composed from arrays of `keys` and `values`. Pass either
+     * a single two dimensional array, i.e. `[[key1, value1], [key2, value2]]`, or
+     * two arrays, one of `keys` and one of corresponding `values`.
+     *
+     * @static
+     * @memberOf _
+     * @category Arrays
+     * @param {Array} keys The array of keys.
+     * @param {Array} [values=[]] The array of values.
+     * @returns {Object} Returns an object composed of the given keys and
+     *  corresponding values.
+     * @example
+     *
+     * _.object(['moe', 'larry'], [30, 40]);
+     * // => { 'moe': 30, 'larry': 40 }
+     */
+    function object(keys, values) {
+      var index = -1,
+          length = keys ? keys.length : 0,
+          result = {};
+
+      while (++index < length) {
+        var key = keys[index];
+        if (values) {
+          result[key] = values[index];
+        } else {
+          result[key[0]] = key[1];
+        }
+      }
+      return result;
+    }
+
+    /**
+     * Creates an array of numbers (positive and/or negative) progressing from
+     * `start` up to but not including `end`.
+     *
+     * @static
+     * @memberOf _
+     * @category Arrays
+     * @param {Number} [start=0] The start of the range.
+     * @param {Number} end The end of the range.
+     * @param {Number} [step=1] The value to increment or descrement by.
+     * @returns {Array} Returns a new range array.
+     * @example
+     *
+     * _.range(10);
+     * // => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+     *
+     * _.range(1, 11);
+     * // => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+     *
+     * _.range(0, 30, 5);
+     * // => [0, 5, 10, 15, 20, 25]
+     *
+     * _.range(0, -10, -1);
+     * // => [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
+     *
+     * _.range(0);
+     * // => []
+     */
+    function range(start, end, step) {
+      start = +start || 0;
+      step = +step || 1;
+
+      if (end == null) {
+        end = start;
+        start = 0;
+      }
+      // use `Array(length)` so V8 will avoid the slower "dictionary" mode
+      // http://youtu.be/XAqIpGU8ZZk#t=17m25s
+      var index = -1,
+          length = nativeMax(0, ceil((end - start) / step)),
+          result = Array(length);
+
+      while (++index < length) {
+        result[index] = start;
+        start += step;
+      }
+      return result;
+    }
+
+    /**
+     * The opposite of `_.initial`, this method gets all but the first value of
+     * `array`. If a number `n` is passed, the first `n` values are excluded from
+     * the result. If a `callback` function is passed, elements at the beginning
+     * of the array are excluded from the result as long as the `callback` returns
+     * truthy. The `callback` is bound to `thisArg` and invoked with three
+     * arguments; (value, index, array).
+     *
+     * If a property name is passed for `callback`, the created "_.pluck" style
+     * callback will return the property value of the given element.
+     *
+     * If an object is passed for `callback`, the created "_.where" style callback
+     * will return `true` for elements that have the propeties of the given object,
+     * else `false`.
+     *
+     * @static
+     * @memberOf _
+     * @alias drop, tail
+     * @category Arrays
+     * @param {Array} array The array to query.
+     * @param {Function|Object|Number|String} [callback|n=1] The function called
+     *  per element or the number of elements to exclude. If a property name or
+     *  object is passed, it will be used to create a "_.pluck" or "_.where"
+     *  style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Array} Returns a slice of `array`.
+     * @example
+     *
+     * _.rest([1, 2, 3]);
+     * // => [2, 3]
+     *
+     * _.rest([1, 2, 3], 2);
+     * // => [3]
+     *
+     * _.rest([1, 2, 3], function(num) {
+     *   return num < 3;
+     * });
+     * // => [3]
+     *
+     * var food = [
+     *   { 'name': 'banana', 'organic': true },
+     *   { 'name': 'beet',   'organic': false },
+     * ];
+     *
+     * // using "_.pluck" callback shorthand
+     * _.rest(food, 'organic');
+     * // => [{ 'name': 'beet', 'organic': false }]
+     *
+     * var food = [
+     *   { 'name': 'apple',  'type': 'fruit' },
+     *   { 'name': 'banana', 'type': 'fruit' },
+     *   { 'name': 'beet',   'type': 'vegetable' }
+     * ];
+     *
+     * // using "_.where" callback shorthand
+     * _.rest(food, { 'type': 'fruit' });
+     * // => [{ 'name': 'beet', 'type': 'vegetable' }]
+     */
+    function rest(array, callback, thisArg) {
+      if (typeof callback != 'number' && callback != null) {
+        var n = 0,
+            index = -1,
+            length = array ? array.length : 0;
+
+        callback = createCallback(callback, thisArg);
+        while (++index < length && callback(array[index], index, array)) {
+          n++;
+        }
+      } else {
+        n = (callback == null || thisArg) ? 1 : nativeMax(0, callback);
+      }
+      return slice(array, n);
+    }
+
+    /**
+     * Uses a binary search to determine the smallest index at which the `value`
+     * should be inserted into `array` in order to maintain the sort order of the
+     * sorted `array`. If `callback` is passed, it will be executed for `value` and
+     * each element in `array` to compute their sort ranking. The `callback` is
+     * bound to `thisArg` and invoked with one argument; (value).
+     *
+     * If a property name is passed for `callback`, the created "_.pluck" style
+     * callback will return the property value of the given element.
+     *
+     * If an object is passed for `callback`, the created "_.where" style callback
+     * will return `true` for elements that have the propeties of the given object,
+     * else `false`.
+     *
+     * @static
+     * @memberOf _
+     * @category Arrays
+     * @param {Array} array The array to iterate over.
+     * @param {Mixed} value The value to evaluate.
+     * @param {Function|Object|String} [callback=identity] The function called per
+     *  iteration. If a property name or object is passed, it will be used to create
+     *  a "_.pluck" or "_.where" style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Number} Returns the index at which the value should be inserted
+     *  into `array`.
+     * @example
+     *
+     * _.sortedIndex([20, 30, 50], 40);
+     * // => 2
+     *
+     * // using "_.pluck" callback shorthand
+     * _.sortedIndex([{ 'x': 20 }, { 'x': 30 }, { 'x': 50 }], { 'x': 40 }, 'x');
+     * // => 2
+     *
+     * var dict = {
+     *   'wordToNumber': { 'twenty': 20, 'thirty': 30, 'fourty': 40, 'fifty': 50 }
+     * };
+     *
+     * _.sortedIndex(['twenty', 'thirty', 'fifty'], 'fourty', function(word) {
+     *   return dict.wordToNumber[word];
+     * });
+     * // => 2
+     *
+     * _.sortedIndex(['twenty', 'thirty', 'fifty'], 'fourty', function(word) {
+     *   return this.wordToNumber[word];
+     * }, dict);
+     * // => 2
+     */
+    function sortedIndex(array, value, callback, thisArg) {
+      var low = 0,
+          high = array ? array.length : low;
+
+      // explicitly reference `identity` for better inlining in Firefox
+      callback = callback ? createCallback(callback, thisArg, 1) : identity;
+      value = callback(value);
+
+      while (low < high) {
+        var mid = (low + high) >>> 1;
+        callback(array[mid]) < value
+          ? low = mid + 1
+          : high = mid;
+      }
+      return low;
+    }
+
+    /**
+     * Computes the union of the passed-in arrays using strict equality for
+     * comparisons, i.e. `===`.
+     *
+     * @static
+     * @memberOf _
+     * @category Arrays
+     * @param {Array} [array1, array2, ...] Arrays to process.
+     * @returns {Array} Returns a new array of unique values, in order, that are
+     *  present in one or more of the arrays.
+     * @example
+     *
+     * _.union([1, 2, 3], [101, 2, 1, 10], [2, 1]);
+     * // => [1, 2, 3, 101, 10]
+     */
+    function union() {
+      return uniq(concat.apply(arrayRef, arguments));
+    }
+
+    /**
+     * Creates a duplicate-value-free version of the `array` using strict equality
+     * for comparisons, i.e. `===`. If the `array` is already sorted, passing `true`
+     * for `isSorted` will run a faster algorithm. If `callback` is passed, each
+     * element of `array` is passed through a callback` before uniqueness is computed.
+     * The `callback` is bound to `thisArg` and invoked with three arguments; (value, index, array).
+     *
+     * If a property name is passed for `callback`, the created "_.pluck" style
+     * callback will return the property value of the given element.
+     *
+     * If an object is passed for `callback`, the created "_.where" style callback
+     * will return `true` for elements that have the propeties of the given object,
+     * else `false`.
+     *
+     * @static
+     * @memberOf _
+     * @alias unique
+     * @category Arrays
+     * @param {Array} array The array to process.
+     * @param {Boolean} [isSorted=false] A flag to indicate that the `array` is already sorted.
+     * @param {Function|Object|String} [callback=identity] The function called per
+     *  iteration. If a property name or object is passed, it will be used to create
+     *  a "_.pluck" or "_.where" style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Array} Returns a duplicate-value-free array.
+     * @example
+     *
+     * _.uniq([1, 2, 1, 3, 1]);
+     * // => [1, 2, 3]
+     *
+     * _.uniq([1, 1, 2, 2, 3], true);
+     * // => [1, 2, 3]
+     *
+     * _.uniq([1, 2, 1.5, 3, 2.5], function(num) { return Math.floor(num); });
+     * // => [1, 2, 3]
+     *
+     * _.uniq([1, 2, 1.5, 3, 2.5], function(num) { return this.floor(num); }, Math);
+     * // => [1, 2, 3]
+     *
+     * // using "_.pluck" callback shorthand
+     * _.uniq([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
+     * // => [{ 'x': 1 }, { 'x': 2 }]
+     */
+    function uniq(array, isSorted, callback, thisArg) {
+      var index = -1,
+          length = array ? array.length : 0,
+          result = [],
+          seen = result;
+
+      // juggle arguments
+      if (typeof isSorted == 'function') {
+        thisArg = callback;
+        callback = isSorted;
+        isSorted = false;
+      }
+      // init value cache for large arrays
+      var isLarge = !isSorted && length >= 75;
+      if (isLarge) {
+        var cache = {};
+      }
+      if (callback) {
+        seen = [];
+        callback = createCallback(callback, thisArg);
+      }
+      while (++index < length) {
+        var value = array[index],
+            computed = callback ? callback(value, index, array) : value;
+
+        if (isLarge) {
+          var key = computed + '';
+          var inited = hasOwnProperty.call(cache, key)
+            ? !(seen = cache[key])
+            : (seen = cache[key] = []);
+        }
+        if (isSorted
+              ? !index || seen[seen.length - 1] !== computed
+              : inited || indexOf(seen, computed) < 0
+            ) {
+          if (callback || isLarge) {
+            seen.push(computed);
+          }
+          result.push(value);
+        }
+      }
+      return result;
+    }
+
+    /**
+     * Creates an array with all occurrences of the passed values removed using
+     * strict equality for comparisons, i.e. `===`.
+     *
+     * @static
+     * @memberOf _
+     * @category Arrays
+     * @param {Array} array The array to filter.
+     * @param {Mixed} [value1, value2, ...] Values to remove.
+     * @returns {Array} Returns a new filtered array.
+     * @example
+     *
+     * _.without([1, 2, 1, 0, 3, 1, 4], 0, 1);
+     * // => [2, 3, 4]
+     */
+    function without(array) {
+      var index = -1,
+          length = array ? array.length : 0,
+          contains = cachedContains(arguments, 1),
+          result = [];
+
+      while (++index < length) {
+        var value = array[index];
+        if (!contains(value)) {
+          result.push(value);
+        }
+      }
+      return result;
+    }
+
+    /**
+     * Groups the elements of each array at their corresponding indexes. Useful for
+     * separate data sources that are coordinated through matching array indexes.
+     * For a matrix of nested arrays, `_.zip.apply(...)` can transpose the matrix
+     * in a similar fashion.
+     *
+     * @static
+     * @memberOf _
+     * @category Arrays
+     * @param {Array} [array1, array2, ...] Arrays to process.
+     * @returns {Array} Returns a new array of grouped elements.
+     * @example
+     *
+     * _.zip(['moe', 'larry'], [30, 40], [true, false]);
+     * // => [['moe', 30, true], ['larry', 40, false]]
+     */
+    function zip(array) {
+      var index = -1,
+          length = array ? max(pluck(arguments, 'length')) : 0,
+          result = Array(length);
+
+      while (++index < length) {
+        result[index] = pluck(arguments, index);
+      }
+      return result;
+    }
+
+    /*--------------------------------------------------------------------------*/
+
+    /**
+     * Creates a function that is restricted to executing `func` only after it is
+     * called `n` times. The `func` is executed with the `this` binding of the
+     * created function.
+     *
+     * @static
+     * @memberOf _
+     * @category Functions
+     * @param {Number} n The number of times the function must be called before
+     * it is executed.
+     * @param {Function} func The function to restrict.
+     * @returns {Function} Returns the new restricted function.
+     * @example
+     *
+     * var renderNotes = _.after(notes.length, render);
+     * _.forEach(notes, function(note) {
+     *   note.asyncSave({ 'success': renderNotes });
+     * });
+     * // `renderNotes` is run once, after all notes have saved
+     */
+    function after(n, func) {
+      if (n < 1) {
+        return func();
+      }
+      return function() {
+        if (--n < 1) {
+          return func.apply(this, arguments);
+        }
+      };
+    }
+
+    /**
+     * Creates a function that, when called, invokes `func` with the `this`
+     * binding of `thisArg` and prepends any additional `bind` arguments to those
+     * passed to the bound function.
+     *
+     * @static
+     * @memberOf _
+     * @category Functions
+     * @param {Function} func The function to bind.
+     * @param {Mixed} [thisArg] The `this` binding of `func`.
+     * @param {Mixed} [arg1, arg2, ...] Arguments to be partially applied.
+     * @returns {Function} Returns the new bound function.
+     * @example
+     *
+     * var func = function(greeting) {
+     *   return greeting + ' ' + this.name;
+     * };
+     *
+     * func = _.bind(func, { 'name': 'moe' }, 'hi');
+     * func();
+     * // => 'hi moe'
+     */
+    function bind(func, thisArg) {
+      // use `Function#bind` if it exists and is fast
+      // (in V8 `Function#bind` is slower except when partially applied)
+      return isBindFast || (nativeBind && arguments.length > 2)
+        ? nativeBind.call.apply(nativeBind, arguments)
+        : createBound(func, thisArg, slice(arguments, 2));
+    }
+
+    /**
+     * Binds methods on `object` to `object`, overwriting the existing method.
+     * Method names may be specified as individual arguments or as arrays of method
+     * names. If no method names are provided, all the function properties of `object`
+     * will be bound.
+     *
+     * @static
+     * @memberOf _
+     * @category Functions
+     * @param {Object} object The object to bind and assign the bound methods to.
+     * @param {String} [methodName1, methodName2, ...] Method names on the object to bind.
+     * @returns {Object} Returns `object`.
+     * @example
+     *
+     * var view = {
+     *  'label': 'docs',
+     *  'onClick': function() { alert('clicked ' + this.label); }
+     * };
+     *
+     * _.bindAll(view);
+     * jQuery('#docs').on('click', view.onClick);
+     * // => alerts 'clicked docs', when the button is clicked
+     */
+    function bindAll(object) {
+      var funcs = concat.apply(arrayRef, arguments),
+          index = funcs.length > 1 ? 0 : (funcs = functions(object), -1),
+          length = funcs.length;
+
+      while (++index < length) {
+        var key = funcs[index];
+        object[key] = bind(object[key], object);
+      }
+      return object;
+    }
+
+    /**
+     * Creates a function that, when called, invokes the method at `object[key]`
+     * and prepends any additional `bindKey` arguments to those passed to the bound
+     * function. This method differs from `_.bind` by allowing bound functions to
+     * reference methods that will be redefined or don't yet exist.
+     * See http://michaux.ca/articles/lazy-function-definition-pattern.
+     *
+     * @static
+     * @memberOf _
+     * @category Functions
+     * @param {Object} object The object the method belongs to.
+     * @param {String} key The key of the method.
+     * @param {Mixed} [arg1, arg2, ...] Arguments to be partially applied.
+     * @returns {Function} Returns the new bound function.
+     * @example
+     *
+     * var object = {
+     *   'name': 'moe',
+     *   'greet': function(greeting) {
+     *     return greeting + ' ' + this.name;
+     *   }
+     * };
+     *
+     * var func = _.bindKey(object, 'greet', 'hi');
+     * func();
+     * // => 'hi moe'
+     *
+     * object.greet = function(greeting) {
+     *   return greeting + ', ' + this.name + '!';
+     * };
+     *
+     * func();
+     * // => 'hi, moe!'
+     */
+    function bindKey(object, key) {
+      return createBound(object, key, slice(arguments, 2));
+    }
+
+    /**
+     * Creates a function that is the composition of the passed functions,
+     * where each function consumes the return value of the function that follows.
+     * For example, composing the functions `f()`, `g()`, and `h()` produces `f(g(h()))`.
+     * Each function is executed with the `this` binding of the composed function.
+     *
+     * @static
+     * @memberOf _
+     * @category Functions
+     * @param {Function} [func1, func2, ...] Functions to compose.
+     * @returns {Function} Returns the new composed function.
+     * @example
+     *
+     * var greet = function(name) { return 'hi ' + name; };
+     * var exclaim = function(statement) { return statement + '!'; };
+     * var welcome = _.compose(exclaim, greet);
+     * welcome('moe');
+     * // => 'hi moe!'
+     */
+    function compose() {
+      var funcs = arguments;
+      return function() {
+        var args = arguments,
+            length = funcs.length;
+
+        while (length--) {
+          args = [funcs[length].apply(this, args)];
+        }
+        return args[0];
+      };
+    }
+
+    /**
+     * Creates a function that will delay the execution of `func` until after
+     * `wait` milliseconds have elapsed since the last time it was invoked. Pass
+     * `true` for `immediate` to cause debounce to invoke `func` on the leading,
+     * instead of the trailing, edge of the `wait` timeout. Subsequent calls to
+     * the debounced function will return the result of the last `func` call.
+     *
+     * @static
+     * @memberOf _
+     * @category Functions
+     * @param {Function} func The function to debounce.
+     * @param {Number} wait The number of milliseconds to delay.
+     * @param {Boolean} immediate A flag to indicate execution is on the leading
+     *  edge of the timeout.
+     * @returns {Function} Returns the new debounced function.
+     * @example
+     *
+     * var lazyLayout = _.debounce(calculateLayout, 300);
+     * jQuery(window).on('resize', lazyLayout);
+     */
+    function debounce(func, wait, immediate) {
+      var args,
+          result,
+          thisArg,
+          timeoutId;
+
+      function delayed() {
+        timeoutId = null;
+        if (!immediate) {
+          result = func.apply(thisArg, args);
+        }
+      }
+      return function() {
+        var isImmediate = immediate && !timeoutId;
+        args = arguments;
+        thisArg = this;
+
+        clearTimeout(timeoutId);
+        timeoutId = setTimeout(delayed, wait);
+
+        if (isImmediate) {
+          result = func.apply(thisArg, args);
+        }
+        return result;
+      };
+    }
+
+    /**
+     * Executes the `func` function after `wait` milliseconds. Additional arguments
+     * will be passed to `func` when it is invoked.
+     *
+     * @static
+     * @memberOf _
+     * @category Functions
+     * @param {Function} func The function to delay.
+     * @param {Number} wait The number of milliseconds to delay execution.
+     * @param {Mixed} [arg1, arg2, ...] Arguments to invoke the function with.
+     * @returns {Number} Returns the timer id.
+     * @example
+     *
+     * var log = _.bind(console.log, console);
+     * _.delay(log, 1000, 'logged later');
+     * // => 'logged later' (Appears after one second.)
+     */
+    function delay(func, wait) {
+      var args = slice(arguments, 2);
+      return setTimeout(function() { func.apply(undefined, args); }, wait);
+    }
+
+    /**
+     * Defers executing the `func` function until the current call stack has cleared.
+     * Additional arguments will be passed to `func` when it is invoked.
+     *
+     * @static
+     * @memberOf _
+     * @category Functions
+     * @param {Function} func The function to defer.
+     * @param {Mixed} [arg1, arg2, ...] Arguments to invoke the function with.
+     * @returns {Number} Returns the timer id.
+     * @example
+     *
+     * _.defer(function() { alert('deferred'); });
+     * // returns from the function before `alert` is called
+     */
+    function defer(func) {
+      var args = slice(arguments, 1);
+      return setTimeout(function() { func.apply(undefined, args); }, 1);
+    }
+    // use `setImmediate` if it's available in Node.js
+    if (isV8 && freeModule && typeof setImmediate == 'function') {
+      defer = bind(setImmediate, context);
+    }
+
+    /**
+     * Creates a function that memoizes the result of `func`. If `resolver` is
+     * passed, it will be used to determine the cache key for storing the result
+     * based on the arguments passed to the memoized function. By default, the first
+     * argument passed to the memoized function is used as the cache key. The `func`
+     * is executed with the `this` binding of the memoized function.
+     *
+     * @static
+     * @memberOf _
+     * @category Functions
+     * @param {Function} func The function to have its output memoized.
+     * @param {Function} [resolver] A function used to resolve the cache key.
+     * @returns {Function} Returns the new memoizing function.
+     * @example
+     *
+     * var fibonacci = _.memoize(function(n) {
+     *   return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);
+     * });
+     */
+    function memoize(func, resolver) {
+      var cache = {};
+      return function() {
+        var key = (resolver ? resolver.apply(this, arguments) : arguments[0]) + '';
+        return hasOwnProperty.call(cache, key)
+          ? cache[key]
+          : (cache[key] = func.apply(this, arguments));
+      };
+    }
+
+    /**
+     * Creates a function that is restricted to execute `func` once. Repeat calls to
+     * the function will return the value of the first call. The `func` is executed
+     * with the `this` binding of the created function.
+     *
+     * @static
+     * @memberOf _
+     * @category Functions
+     * @param {Function} func The function to restrict.
+     * @returns {Function} Returns the new restricted function.
+     * @example
+     *
+     * var initialize = _.once(createApplication);
+     * initialize();
+     * initialize();
+     * // `initialize` executes `createApplication` once
+     */
+    function once(func) {
+      var ran,
+          result;
+
+      return function() {
+        if (ran) {
+          return result;
+        }
+        ran = true;
+        result = func.apply(this, arguments);
+
+        // clear the `func` variable so the function may be garbage collected
+        func = null;
+        return result;
+      };
+    }
+
+    /**
+     * Creates a function that, when called, invokes `func` with any additional
+     * `partial` arguments prepended to those passed to the new function. This
+     * method is similar to `_.bind`, except it does **not** alter the `this` binding.
+     *
+     * @static
+     * @memberOf _
+     * @category Functions
+     * @param {Function} func The function to partially apply arguments to.
+     * @param {Mixed} [arg1, arg2, ...] Arguments to be partially applied.
+     * @returns {Function} Returns the new partially applied function.
+     * @example
+     *
+     * var greet = function(greeting, name) { return greeting + ' ' + name; };
+     * var hi = _.partial(greet, 'hi');
+     * hi('moe');
+     * // => 'hi moe'
+     */
+    function partial(func) {
+      return createBound(func, slice(arguments, 1));
+    }
+
+    /**
+     * This method is similar to `_.partial`, except that `partial` arguments are
+     * appended to those passed to the new function.
+     *
+     * @static
+     * @memberOf _
+     * @category Functions
+     * @param {Function} func The function to partially apply arguments to.
+     * @param {Mixed} [arg1, arg2, ...] Arguments to be partially applied.
+     * @returns {Function} Returns the new partially applied function.
+     * @example
+     *
+     * var defaultsDeep = _.partialRight(_.merge, _.defaults);
+     *
+     * var options = {
+     *   'variable': 'data',
+     *   'imports': { 'jq': $ }
+     * };
+     *
+     * defaultsDeep(options, _.templateSettings);
+     *
+     * options.variable
+     * // => 'data'
+     *
+     * options.imports
+     * // => { '_': _, 'jq': $ }
+     */
+    function partialRight(func) {
+      return createBound(func, slice(arguments, 1), null, indicatorObject);
+    }
+
+    /**
+     * Creates a function that, when executed, will only call the `func`
+     * function at most once per every `wait` milliseconds. If the throttled
+     * function is invoked more than once during the `wait` timeout, `func` will
+     * also be called on the trailing edge of the timeout. Subsequent calls to the
+     * throttled function will return the result of the last `func` call.
+     *
+     * @static
+     * @memberOf _
+     * @category Functions
+     * @param {Function} func The function to throttle.
+     * @param {Number} wait The number of milliseconds to throttle executions to.
+     * @returns {Function} Returns the new throttled function.
+     * @example
+     *
+     * var throttled = _.throttle(updatePosition, 100);
+     * jQuery(window).on('scroll', throttled);
+     */
+    function throttle(func, wait) {
+      var args,
+          result,
+          thisArg,
+          timeoutId,
+          lastCalled = 0;
+
+      function trailingCall() {
+        lastCalled = new Date;
+        timeoutId = null;
+        result = func.apply(thisArg, args);
+      }
+      return function() {
+        var now = new Date,
+            remaining = wait - (now - lastCalled);
+
+        args = arguments;
+        thisArg = this;
+
+        if (remaining <= 0) {
+          clearTimeout(timeoutId);
+          timeoutId = null;
+          lastCalled = now;
+          result = func.apply(thisArg, args);
+        }
+        else if (!timeoutId) {
+          timeoutId = setTimeout(trailingCall, remaining);
+        }
+        return result;
+      };
+    }
+
+    /**
+     * Creates a function that passes `value` to the `wrapper` function as its
+     * first argument. Additional arguments passed to the function are appended
+     * to those passed to the `wrapper` function. The `wrapper` is executed with
+     * the `this` binding of the created function.
+     *
+     * @static
+     * @memberOf _
+     * @category Functions
+     * @param {Mixed} value The value to wrap.
+     * @param {Function} wrapper The wrapper function.
+     * @returns {Function} Returns the new function.
+     * @example
+     *
+     * var hello = function(name) { return 'hello ' + name; };
+     * hello = _.wrap(hello, function(func) {
+     *   return 'before, ' + func('moe') + ', after';
+     * });
+     * hello();
+     * // => 'before, hello moe, after'
+     */
+    function wrap(value, wrapper) {
+      return function() {
+        var args = [value];
+        push.apply(args, arguments);
+        return wrapper.apply(this, args);
+      };
+    }
+
+    /*--------------------------------------------------------------------------*/
+
+    /**
+     * Converts the characters `&`, `<`, `>`, `"`, and `'` in `string` to their
+     * corresponding HTML entities.
+     *
+     * @static
+     * @memberOf _
+     * @category Utilities
+     * @param {String} string The string to escape.
+     * @returns {String} Returns the escaped string.
+     * @example
+     *
+     * _.escape('Moe, Larry & Curly');
+     * // => 'Moe, Larry &amp; Curly'
+     */
+    function escape(string) {
+      return string == null ? '' : (string + '').replace(reUnescapedHtml, escapeHtmlChar);
+    }
+
+    /**
+     * This function returns the first argument passed to it.
+     *
+     * @static
+     * @memberOf _
+     * @category Utilities
+     * @param {Mixed} value Any value.
+     * @returns {Mixed} Returns `value`.
+     * @example
+     *
+     * var moe = { 'name': 'moe' };
+     * moe === _.identity(moe);
+     * // => true
+     */
+    function identity(value) {
+      return value;
+    }
+
+    /**
+     * Adds functions properties of `object` to the `lodash` function and chainable
+     * wrapper.
+     *
+     * @static
+     * @memberOf _
+     * @category Utilities
+     * @param {Object} object The object of function properties to add to `lodash`.
+     * @example
+     *
+     * _.mixin({
+     *   'capitalize': function(string) {
+     *     return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();
+     *   }
+     * });
+     *
+     * _.capitalize('moe');
+     * // => 'Moe'
+     *
+     * _('moe').capitalize();
+     * // => 'Moe'
+     */
+    function mixin(object) {
+      forEach(functions(object), function(methodName) {
+        var func = lodash[methodName] = object[methodName];
+
+        lodash.prototype[methodName] = function() {
+          var args = [this.__wrapped__];
+          push.apply(args, arguments);
+          return new lodash(func.apply(lodash, args));
+        };
+      });
+    }
+
+    /**
+     * Reverts the '_' variable to its previous value and returns a reference to
+     * the `lodash` function.
+     *
+     * @static
+     * @memberOf _
+     * @category Utilities
+     * @returns {Function} Returns the `lodash` function.
+     * @example
+     *
+     * var lodash = _.noConflict();
+     */
+    function noConflict() {
+      context._ = oldDash;
+      return this;
+    }
+
+    /**
+     * Produces a random number between `min` and `max` (inclusive). If only one
+     * argument is passed, a number between `0` and the given number will be returned.
+     *
+     * @static
+     * @memberOf _
+     * @category Utilities
+     * @param {Number} [min=0] The minimum possible value.
+     * @param {Number} [max=1] The maximum possible value.
+     * @returns {Number} Returns a random number.
+     * @example
+     *
+     * _.random(0, 5);
+     * // => a number between 0 and 5
+     *
+     * _.random(5);
+     * // => also a number between 0 and 5
+     */
+    function random(min, max) {
+      if (min == null && max == null) {
+        max = 1;
+      }
+      min = +min || 0;
+      if (max == null) {
+        max = min;
+        min = 0;
+      }
+      return min + floor(nativeRandom() * ((+max || 0) - min + 1));
+    }
+
+    /**
+     * Resolves the value of `property` on `object`. If `property` is a function,
+     * it will be invoked and its result returned, else the property value is
+     * returned. If `object` is falsey, then `null` is returned.
+     *
+     * @static
+     * @memberOf _
+     * @category Utilities
+     * @param {Object} object The object to inspect.
+     * @param {String} property The property to get the value of.
+     * @returns {Mixed} Returns the resolved value.
+     * @example
+     *
+     * var object = {
+     *   'cheese': 'crumpets',
+     *   'stuff': function() {
+     *     return 'nonsense';
+     *   }
+     * };
+     *
+     * _.result(object, 'cheese');
+     * // => 'crumpets'
+     *
+     * _.result(object, 'stuff');
+     * // => 'nonsense'
+     */
+    function result(object, property) {
+      var value = object ? object[property] : undefined;
+      return isFunction(value) ? object[property]() : value;
+    }
+
+    /**
+     * A micro-templating method that handles arbitrary delimiters, preserves
+     * whitespace, and correctly escapes quotes within interpolated code.
+     *
+     * Note: In the development build, `_.template` utilizes sourceURLs for easier
+     * debugging. See http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl
+     *
+     * Note: Lo-Dash may be used in Chrome extensions by either creating a `lodash csp`
+     * build and using precompiled templates, or loading Lo-Dash in a sandbox.
+     *
+     * For more information on precompiling templates see:
+     * http://lodash.com/#custom-builds
+     *
+     * For more information on Chrome extension sandboxes see:
+     * http://developer.chrome.com/stable/extensions/sandboxingEval.html
+     *
+     * @static
+     * @memberOf _
+     * @category Utilities
+     * @param {String} text The template text.
+     * @param {Obect} data The data object used to populate the text.
+     * @param {Object} options The options object.
+     *  escape - The "escape" delimiter regexp.
+     *  evaluate - The "evaluate" delimiter regexp.
+     *  interpolate - The "interpolate" delimiter regexp.
+     *  sourceURL - The sourceURL of the template's compiled source.
+     *  variable - The data object variable name.
+     * @returns {Function|String} Returns a compiled function when no `data` object
+     *  is given, else it returns the interpolated text.
+     * @example
+     *
+     * // using a compiled template
+     * var compiled = _.template('hello <%= name %>');
+     * compiled({ 'name': 'moe' });
+     * // => 'hello moe'
+     *
+     * var list = '<% _.forEach(people, function(name) { %><li><%= name %></li><% }); %>';
+     * _.template(list, { 'people': ['moe', 'larry'] });
+     * // => '<li>moe</li><li>larry</li>'
+     *
+     * // using the "escape" delimiter to escape HTML in data property values
+     * _.template('<b><%- value %></b>', { 'value': '<script>' });
+     * // => '<b>&lt;script&gt;</b>'
+     *
+     * // using the ES6 delimiter as an alternative to the default "interpolate" delimiter
+     * _.template('hello ${ name }', { 'name': 'curly' });
+     * // => 'hello curly'
+     *
+     * // using the internal `print` function in "evaluate" delimiters
+     * _.template('<% print("hello " + epithet); %>!', { 'epithet': 'stooge' });
+     * // => 'hello stooge!'
+     *
+     * // using custom template delimiters
+     * _.templateSettings = {
+     *   'interpolate': /{{([\s\S]+?)}}/g
+     * };
+     *
+     * _.template('hello {{ name }}!', { 'name': 'mustache' });
+     * // => 'hello mustache!'
+     *
+     * // using the `sourceURL` option to specify a custom sourceURL for the template
+     * var compiled = _.template('hello <%= name %>', null, { 'sourceURL': '/basic/greeting.jst' });
+     * compiled(data);
+     * // => find the source of "greeting.jst" under the Sources tab or Resources panel of the web inspector
+     *
+     * // using the `variable` option to ensure a with-statement isn't used in the compiled template
+     * var compiled = _.template('hi <%= data.name %>!', null, { 'variable': 'data' });
+     * compiled.source;
+     * // => function(data) {
+     *   var __t, __p = '', __e = _.escape;
+     *   __p += 'hi ' + ((__t = ( data.name )) == null ? '' : __t) + '!';
+     *   return __p;
+     * }
+     *
+     * // using the `source` property to inline compiled templates for meaningful
+     * // line numbers in error messages and a stack trace
+     * fs.writeFileSync(path.join(cwd, 'jst.js'), '\
+     *   var JST = {\
+     *     "main": ' + _.template(mainText).source + '\
+     *   };\
+     * ');
+     */
+    function template(text, data, options) {
+      // based on John Resig's `tmpl` implementation
+      // http://ejohn.org/blog/javascript-micro-templating/
+      // and Laura Doktorova's doT.js
+      // https://github.com/olado/doT
+      var settings = lodash.templateSettings;
+      text || (text = '');
+
+      // avoid missing dependencies when `iteratorTemplate` is not defined
+      options = defaults({}, options, settings);
+
+      var imports = defaults({}, options.imports, settings.imports),
+          importsKeys = keys(imports),
+          importsValues = values(imports);
+
+      var isEvaluating,
+          index = 0,
+          interpolate = options.interpolate || reNoMatch,
+          source = "__p += '";
+
+      // compile the regexp to match each delimiter
+      var reDelimiters = RegExp(
+        (options.escape || reNoMatch).source + '|' +
+        interpolate.source + '|' +
+        (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + '|' +
+        (options.evaluate || reNoMatch).source + '|$'
+      , 'g');
+
+      text.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) {
+        interpolateValue || (interpolateValue = esTemplateValue);
+
+        // escape characters that cannot be included in string literals
+        source += text.slice(index, offset).replace(reUnescapedString, escapeStringChar);
+
+        // replace delimiters with snippets
+        if (escapeValue) {
+          source += "' +\n__e(" + escapeValue + ") +\n'";
+        }
+        if (evaluateValue) {
+          isEvaluating = true;
+          source += "';\n" + evaluateValue + ";\n__p += '";
+        }
+        if (interpolateValue) {
+          source += "' +\n((__t = (" + interpolateValue + ")) == null ? '' : __t) +\n'";
+        }
+        index = offset + match.length;
+
+        // the JS engine embedded in Adobe products requires returning the `match`
+        // string in order to produce the correct `offset` value
+        return match;
+      });
+
+      source += "';\n";
+
+      // if `variable` is not specified, wrap a with-statement around the generated
+      // code to add the data object to the top of the scope chain
+      var variable = options.variable,
+          hasVariable = variable;
+
+      if (!hasVariable) {
+        variable = 'obj';
+        source = 'with (' + variable + ') {\n' + source + '\n}\n';
+      }
+      // cleanup code by stripping empty strings
+      source = (isEvaluating ? source.replace(reEmptyStringLeading, '') : source)
+        .replace(reEmptyStringMiddle, '$1')
+        .replace(reEmptyStringTrailing, '$1;');
+
+      // frame code as the function body
+      source = 'function(' + variable + ') {\n' +
+        (hasVariable ? '' : variable + ' || (' + variable + ' = {});\n') +
+        "var __t, __p = '', __e = _.escape" +
+        (isEvaluating
+          ? ', __j = Array.prototype.join;\n' +
+            "function print() { __p += __j.call(arguments, '') }\n"
+          : ';\n'
+        ) +
+        source +
+        'return __p\n}';
+
+      // Use a sourceURL for easier debugging and wrap in a multi-line comment to
+      // avoid issues with Narwhal, IE conditional compilation, and the JS engine
+      // embedded in Adobe products.
+      // http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl
+      var sourceURL = '\n/*\n//@ sourceURL=' + (options.sourceURL || '/lodash/template/source[' + (templateCounter++) + ']') + '\n*/';
+
+      try {
+        var result = Function(importsKeys, 'return ' + source + sourceURL).apply(undefined, importsValues);
+      } catch(e) {
+        e.source = source;
+        throw e;
+      }
+      if (data) {
+        return result(data);
+      }
+      // provide the compiled function's source via its `toString` method, in
+      // supported environments, or the `source` property as a convenience for
+      // inlining compiled templates during the build process
+      result.source = source;
+      return result;
+    }
+
+    /**
+     * Executes the `callback` function `n` times, returning an array of the results
+     * of each `callback` execution. The `callback` is bound to `thisArg` and invoked
+     * with one argument; (index).
+     *
+     * @static
+     * @memberOf _
+     * @category Utilities
+     * @param {Number} n The number of times to execute the callback.
+     * @param {Function} callback The function called per iteration.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Array} Returns a new array of the results of each `callback` execution.
+     * @example
+     *
+     * var diceRolls = _.times(3, _.partial(_.random, 1, 6));
+     * // => [3, 6, 4]
+     *
+     * _.times(3, function(n) { mage.castSpell(n); });
+     * // => calls `mage.castSpell(n)` three times, passing `n` of `0`, `1`, and `2` respectively
+     *
+     * _.times(3, function(n) { this.cast(n); }, mage);
+     * // => also calls `mage.castSpell(n)` three times
+     */
+    function times(n, callback, thisArg) {
+      n = +n || 0;
+      var index = -1,
+          result = Array(n);
+
+      while (++index < n) {
+        result[index] = callback.call(thisArg, index);
+      }
+      return result;
+    }
+
+    /**
+     * The opposite of `_.escape`, this method converts the HTML entities
+     * `&amp;`, `&lt;`, `&gt;`, `&quot;`, and `&#39;` in `string` to their
+     * corresponding characters.
+     *
+     * @static
+     * @memberOf _
+     * @category Utilities
+     * @param {String} string The string to unescape.
+     * @returns {String} Returns the unescaped string.
+     * @example
+     *
+     * _.unescape('Moe, Larry &amp; Curly');
+     * // => 'Moe, Larry & Curly'
+     */
+    function unescape(string) {
+      return string == null ? '' : (string + '').replace(reEscapedHtml, unescapeHtmlChar);
+    }
+
+    /**
+     * Generates a unique ID. If `prefix` is passed, the ID will be appended to it.
+     *
+     * @static
+     * @memberOf _
+     * @category Utilities
+     * @param {String} [prefix] The value to prefix the ID with.
+     * @returns {String} Returns the unique ID.
+     * @example
+     *
+     * _.uniqueId('contact_');
+     * // => 'contact_104'
+     *
+     * _.uniqueId();
+     * // => '105'
+     */
+    function uniqueId(prefix) {
+      var id = ++idCounter;
+      return (prefix == null ? '' : prefix + '') + id;
+    }
+
+    /*--------------------------------------------------------------------------*/
+
+    /**
+     * Invokes `interceptor` with the `value` as the first argument, and then
+     * returns `value`. The purpose of this method is to "tap into" a method chain,
+     * in order to perform operations on intermediate results within the chain.
+     *
+     * @static
+     * @memberOf _
+     * @category Chaining
+     * @param {Mixed} value The value to pass to `interceptor`.
+     * @param {Function} interceptor The function to invoke.
+     * @returns {Mixed} Returns `value`.
+     * @example
+     *
+     * _([1, 2, 3, 4])
+     *  .filter(function(num) { return num % 2 == 0; })
+     *  .tap(alert)
+     *  .map(function(num) { return num * num; })
+     *  .value();
+     * // => // [2, 4] (alerted)
+     * // => [4, 16]
+     */
+    function tap(value, interceptor) {
+      interceptor(value);
+      return value;
+    }
+
+    /**
+     * Produces the `toString` result of the wrapped value.
+     *
+     * @name toString
+     * @memberOf _
+     * @category Chaining
+     * @returns {String} Returns the string result.
+     * @example
+     *
+     * _([1, 2, 3]).toString();
+     * // => '1,2,3'
+     */
+    function wrapperToString() {
+      return this.__wrapped__ + '';
+    }
+
+    /**
+     * Extracts the wrapped value.
+     *
+     * @name valueOf
+     * @memberOf _
+     * @alias value
+     * @category Chaining
+     * @returns {Mixed} Returns the wrapped value.
+     * @example
+     *
+     * _([1, 2, 3]).valueOf();
+     * // => [1, 2, 3]
+     */
+    function wrapperValueOf() {
+      return this.__wrapped__;
+    }
+
+    /*--------------------------------------------------------------------------*/
+
+    // add functions that return wrapped values when chaining
+    lodash.after = after;
+    lodash.assign = assign;
+    lodash.at = at;
+    lodash.bind = bind;
+    lodash.bindAll = bindAll;
+    lodash.bindKey = bindKey;
+    lodash.compact = compact;
+    lodash.compose = compose;
+    lodash.countBy = countBy;
+    lodash.debounce = debounce;
+    lodash.defaults = defaults;
+    lodash.defer = defer;
+    lodash.delay = delay;
+    lodash.difference = difference;
+    lodash.filter = filter;
+    lodash.flatten = flatten;
+    lodash.forEach = forEach;
+    lodash.forIn = forIn;
+    lodash.forOwn = forOwn;
+    lodash.functions = functions;
+    lodash.groupBy = groupBy;
+    lodash.initial = initial;
+    lodash.intersection = intersection;
+    lodash.invert = invert;
+    lodash.invoke = invoke;
+    lodash.keys = keys;
+    lodash.map = map;
+    lodash.max = max;
+    lodash.memoize = memoize;
+    lodash.merge = merge;
+    lodash.min = min;
+    lodash.object = object;
+    lodash.omit = omit;
+    lodash.once = once;
+    lodash.pairs = pairs;
+    lodash.partial = partial;
+    lodash.partialRight = partialRight;
+    lodash.pick = pick;
+    lodash.pluck = pluck;
+    lodash.range = range;
+    lodash.reject = reject;
+    lodash.rest = rest;
+    lodash.shuffle = shuffle;
+    lodash.sortBy = sortBy;
+    lodash.tap = tap;
+    lodash.throttle = throttle;
+    lodash.times = times;
+    lodash.toArray = toArray;
+    lodash.union = union;
+    lodash.uniq = uniq;
+    lodash.values = values;
+    lodash.where = where;
+    lodash.without = without;
+    lodash.wrap = wrap;
+    lodash.zip = zip;
+
+    // add aliases
+    lodash.collect = map;
+    lodash.drop = rest;
+    lodash.each = forEach;
+    lodash.extend = assign;
+    lodash.methods = functions;
+    lodash.select = filter;
+    lodash.tail = rest;
+    lodash.unique = uniq;
+
+    // add functions to `lodash.prototype`
+    mixin(lodash);
+
+    /*--------------------------------------------------------------------------*/
+
+    // add functions that return unwrapped values when chaining
+    lodash.clone = clone;
+    lodash.cloneDeep = cloneDeep;
+    lodash.contains = contains;
+    lodash.escape = escape;
+    lodash.every = every;
+    lodash.find = find;
+    lodash.has = has;
+    lodash.identity = identity;
+    lodash.indexOf = indexOf;
+    lodash.isArguments = isArguments;
+    lodash.isArray = isArray;
+    lodash.isBoolean = isBoolean;
+    lodash.isDate = isDate;
+    lodash.isElement = isElement;
+    lodash.isEmpty = isEmpty;
+    lodash.isEqual = isEqual;
+    lodash.isFinite = isFinite;
+    lodash.isFunction = isFunction;
+    lodash.isNaN = isNaN;
+    lodash.isNull = isNull;
+    lodash.isNumber = isNumber;
+    lodash.isObject = isObject;
+    lodash.isPlainObject = isPlainObject;
+    lodash.isRegExp = isRegExp;
+    lodash.isString = isString;
+    lodash.isUndefined = isUndefined;
+    lodash.lastIndexOf = lastIndexOf;
+    lodash.mixin = mixin;
+    lodash.noConflict = noConflict;
+    lodash.parseInt = parseInt;
+    lodash.random = random;
+    lodash.reduce = reduce;
+    lodash.reduceRight = reduceRight;
+    lodash.result = result;
+    lodash.runInContext = runInContext;
+    lodash.size = size;
+    lodash.some = some;
+    lodash.sortedIndex = sortedIndex;
+    lodash.template = template;
+    lodash.unescape = unescape;
+    lodash.uniqueId = uniqueId;
+
+    // add aliases
+    lodash.all = every;
+    lodash.any = some;
+    lodash.detect = find;
+    lodash.foldl = reduce;
+    lodash.foldr = reduceRight;
+    lodash.include = contains;
+    lodash.inject = reduce;
+
+    forOwn(lodash, function(func, methodName) {
+      if (!lodash.prototype[methodName]) {
+        lodash.prototype[methodName] = function() {
+          var args = [this.__wrapped__];
+          push.apply(args, arguments);
+          return func.apply(lodash, args);
+        };
+      }
+    });
+
+    /*--------------------------------------------------------------------------*/
+
+    // add functions capable of returning wrapped and unwrapped values when chaining
+    lodash.first = first;
+    lodash.last = last;
+
+    // add aliases
+    lodash.take = first;
+    lodash.head = first;
+
+    forOwn(lodash, function(func, methodName) {
+      if (!lodash.prototype[methodName]) {
+        lodash.prototype[methodName]= function(callback, thisArg) {
+          var result = func(this.__wrapped__, callback, thisArg);
+          return callback == null || (thisArg && typeof callback != 'function')
+            ? result
+            : new lodash(result);
+        };
+      }
+    });
+
+    /*--------------------------------------------------------------------------*/
+
+    /**
+     * The semantic version number.
+     *
+     * @static
+     * @memberOf _
+     * @type String
+     */
+    lodash.VERSION = '1.0.1';
+
+    // add "Chaining" functions to the wrapper
+    lodash.prototype.toString = wrapperToString;
+    lodash.prototype.value = wrapperValueOf;
+    lodash.prototype.valueOf = wrapperValueOf;
+
+    // add `Array` functions that return unwrapped values
+    each(['join', 'pop', 'shift'], function(methodName) {
+      var func = arrayRef[methodName];
+      lodash.prototype[methodName] = function() {
+        return func.apply(this.__wrapped__, arguments);
+      };
+    });
+
+    // add `Array` functions that return the wrapped value
+    each(['push', 'reverse', 'sort', 'unshift'], function(methodName) {
+      var func = arrayRef[methodName];
+      lodash.prototype[methodName] = function() {
+        func.apply(this.__wrapped__, arguments);
+        return this;
+      };
+    });
+
+    // add `Array` functions that return new wrapped values
+    each(['concat', 'slice', 'splice'], function(methodName) {
+      var func = arrayRef[methodName];
+      lodash.prototype[methodName] = function() {
+        return new lodash(func.apply(this.__wrapped__, arguments));
+      };
+    });
+
+    return lodash;
+  }
+
+  /*--------------------------------------------------------------------------*/
+
+  // expose Lo-Dash
+  var _ = runInContext();
+
+  // some AMD build optimizers, like r.js, check for specific condition patterns like the following:
+  if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {
+    // Expose Lo-Dash to the global object even when an AMD loader is present in
+    // case Lo-Dash was injected by a third-party script and not intended to be
+    // loaded as a module. The global assignment can be reverted in the Lo-Dash
+    // module via its `noConflict()` method.
+    window._ = _;
+
+    // define as an anonymous module so, through path mapping, it can be
+    // referenced as the "underscore" module
+    define(function() {
+      return _;
+    });
+  }
+  // check for `exports` after `define` in case a build optimizer adds an `exports` object
+  else if (freeExports && !freeExports.nodeType) {
+    // in Node.js or RingoJS v0.8.0+
+    if (freeModule) {
+      (freeModule.exports = _)._ = _;
+    }
+    // in Narwhal or RingoJS v0.7.0-
+    else {
+      freeExports._ = _;
+    }
+  }
+  else {
+    // in a browser or Rhino
+    window._ = _;
+  }
+}(this));
diff --git a/module/web/static/js/libs/require-2.1.5.js b/module/web/static/js/libs/require-2.1.5.js
new file mode 100644
index 000000000..062516acd
--- /dev/null
+++ b/module/web/static/js/libs/require-2.1.5.js
@@ -0,0 +1,2019 @@
+/** vim: et:ts=4:sw=4:sts=4
+ * @license RequireJS 2.1.5 Copyright (c) 2010-2012, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/requirejs for details
+ */
+//Not using strict: uneven strict support in browsers, #392, and causes
+//problems with requirejs.exec()/transpiler plugins that may not be strict.
+/*jslint regexp: true, nomen: true, sloppy: true */
+/*global window, navigator, document, importScripts, setTimeout, opera */
+
+var requirejs, require, define;
+(function (global) {
+    var req, s, head, baseElement, dataMain, src,
+        interactiveScript, currentlyAddingScript, mainScript, subPath,
+        version = '2.1.5',
+        commentRegExp = /(\/\*([\s\S]*?)\*\/|([^:]|^)\/\/(.*)$)/mg,
+        cjsRequireRegExp = /[^.]\s*require\s*\(\s*["']([^'"\s]+)["']\s*\)/g,
+        jsSuffixRegExp = /\.js$/,
+        currDirRegExp = /^\.\//,
+        op = Object.prototype,
+        ostring = op.toString,
+        hasOwn = op.hasOwnProperty,
+        ap = Array.prototype,
+        apsp = ap.splice,
+        isBrowser = !!(typeof window !== 'undefined' && navigator && document),
+        isWebWorker = !isBrowser && typeof importScripts !== 'undefined',
+        //PS3 indicates loaded and complete, but need to wait for complete
+        //specifically. Sequence is 'loading', 'loaded', execution,
+        // then 'complete'. The UA check is unfortunate, but not sure how
+        //to feature test w/o causing perf issues.
+        readyRegExp = isBrowser && navigator.platform === 'PLAYSTATION 3' ?
+                      /^complete$/ : /^(complete|loaded)$/,
+        defContextName = '_',
+        //Oh the tragedy, detecting opera. See the usage of isOpera for reason.
+        isOpera = typeof opera !== 'undefined' && opera.toString() === '[object Opera]',
+        contexts = {},
+        cfg = {},
+        globalDefQueue = [],
+        useInteractive = false;
+
+    function isFunction(it) {
+        return ostring.call(it) === '[object Function]';
+    }
+
+    function isArray(it) {
+        return ostring.call(it) === '[object Array]';
+    }
+
+    /**
+     * Helper function for iterating over an array. If the func returns
+     * a true value, it will break out of the loop.
+     */
+    function each(ary, func) {
+        if (ary) {
+            var i;
+            for (i = 0; i < ary.length; i += 1) {
+                if (ary[i] && func(ary[i], i, ary)) {
+                    break;
+                }
+            }
+        }
+    }
+
+    /**
+     * Helper function for iterating over an array backwards. If the func
+     * returns a true value, it will break out of the loop.
+     */
+    function eachReverse(ary, func) {
+        if (ary) {
+            var i;
+            for (i = ary.length - 1; i > -1; i -= 1) {
+                if (ary[i] && func(ary[i], i, ary)) {
+                    break;
+                }
+            }
+        }
+    }
+
+    function hasProp(obj, prop) {
+        return hasOwn.call(obj, prop);
+    }
+
+    function getOwn(obj, prop) {
+        return hasProp(obj, prop) && obj[prop];
+    }
+
+    /**
+     * Cycles over properties in an object and calls a function for each
+     * property value. If the function returns a truthy value, then the
+     * iteration is stopped.
+     */
+    function eachProp(obj, func) {
+        var prop;
+        for (prop in obj) {
+            if (hasProp(obj, prop)) {
+                if (func(obj[prop], prop)) {
+                    break;
+                }
+            }
+        }
+    }
+
+    /**
+     * Simple function to mix in properties from source into target,
+     * but only if target does not already have a property of the same name.
+     */
+    function mixin(target, source, force, deepStringMixin) {
+        if (source) {
+            eachProp(source, function (value, prop) {
+                if (force || !hasProp(target, prop)) {
+                    if (deepStringMixin && typeof value !== 'string') {
+                        if (!target[prop]) {
+                            target[prop] = {};
+                        }
+                        mixin(target[prop], value, force, deepStringMixin);
+                    } else {
+                        target[prop] = value;
+                    }
+                }
+            });
+        }
+        return target;
+    }
+
+    //Similar to Function.prototype.bind, but the 'this' object is specified
+    //first, since it is easier to read/figure out what 'this' will be.
+    function bind(obj, fn) {
+        return function () {
+            return fn.apply(obj, arguments);
+        };
+    }
+
+    function scripts() {
+        return document.getElementsByTagName('script');
+    }
+
+    //Allow getting a global that expressed in
+    //dot notation, like 'a.b.c'.
+    function getGlobal(value) {
+        if (!value) {
+            return value;
+        }
+        var g = global;
+        each(value.split('.'), function (part) {
+            g = g[part];
+        });
+        return g;
+    }
+
+    /**
+     * Constructs an error with a pointer to an URL with more information.
+     * @param {String} id the error ID that maps to an ID on a web page.
+     * @param {String} message human readable error.
+     * @param {Error} [err] the original error, if there is one.
+     *
+     * @returns {Error}
+     */
+    function makeError(id, msg, err, requireModules) {
+        var e = new Error(msg + '\nhttp://requirejs.org/docs/errors.html#' + id);
+        e.requireType = id;
+        e.requireModules = requireModules;
+        if (err) {
+            e.originalError = err;
+        }
+        return e;
+    }
+
+    if (typeof define !== 'undefined') {
+        //If a define is already in play via another AMD loader,
+        //do not overwrite.
+        return;
+    }
+
+    if (typeof requirejs !== 'undefined') {
+        if (isFunction(requirejs)) {
+            //Do not overwrite and existing requirejs instance.
+            return;
+        }
+        cfg = requirejs;
+        requirejs = undefined;
+    }
+
+    //Allow for a require config object
+    if (typeof require !== 'undefined' && !isFunction(require)) {
+        //assume it is a config object.
+        cfg = require;
+        require = undefined;
+    }
+
+    function newContext(contextName) {
+        var inCheckLoaded, Module, context, handlers,
+            checkLoadedTimeoutId,
+            config = {
+                //Defaults. Do not set a default for map
+                //config to speed up normalize(), which
+                //will run faster if there is no default.
+                waitSeconds: 7,
+                baseUrl: './',
+                paths: {},
+                pkgs: {},
+                shim: {},
+                config: {}
+            },
+            registry = {},
+            //registry of just enabled modules, to speed
+            //cycle breaking code when lots of modules
+            //are registered, but not activated.
+            enabledRegistry = {},
+            undefEvents = {},
+            defQueue = [],
+            defined = {},
+            urlFetched = {},
+            requireCounter = 1,
+            unnormalizedCounter = 1;
+
+        /**
+         * Trims the . and .. from an array of path segments.
+         * It will keep a leading path segment if a .. will become
+         * the first path segment, to help with module name lookups,
+         * which act like paths, but can be remapped. But the end result,
+         * all paths that use this function should look normalized.
+         * NOTE: this method MODIFIES the input array.
+         * @param {Array} ary the array of path segments.
+         */
+        function trimDots(ary) {
+            var i, part;
+            for (i = 0; ary[i]; i += 1) {
+                part = ary[i];
+                if (part === '.') {
+                    ary.splice(i, 1);
+                    i -= 1;
+                } else if (part === '..') {
+                    if (i === 1 && (ary[2] === '..' || ary[0] === '..')) {
+                        //End of the line. Keep at least one non-dot
+                        //path segment at the front so it can be mapped
+                        //correctly to disk. Otherwise, there is likely
+                        //no path mapping for a path starting with '..'.
+                        //This can still fail, but catches the most reasonable
+                        //uses of ..
+                        break;
+                    } else if (i > 0) {
+                        ary.splice(i - 1, 2);
+                        i -= 2;
+                    }
+                }
+            }
+        }
+
+        /**
+         * Given a relative module name, like ./something, normalize it to
+         * a real name that can be mapped to a path.
+         * @param {String} name the relative name
+         * @param {String} baseName a real name that the name arg is relative
+         * to.
+         * @param {Boolean} applyMap apply the map config to the value. Should
+         * only be done if this normalization is for a dependency ID.
+         * @returns {String} normalized name
+         */
+        function normalize(name, baseName, applyMap) {
+            var pkgName, pkgConfig, mapValue, nameParts, i, j, nameSegment,
+                foundMap, foundI, foundStarMap, starI,
+                baseParts = baseName && baseName.split('/'),
+                normalizedBaseParts = baseParts,
+                map = config.map,
+                starMap = map && map['*'];
+
+            //Adjust any relative paths.
+            if (name && name.charAt(0) === '.') {
+                //If have a base name, try to normalize against it,
+                //otherwise, assume it is a top-level require that will
+                //be relative to baseUrl in the end.
+                if (baseName) {
+                    if (getOwn(config.pkgs, baseName)) {
+                        //If the baseName is a package name, then just treat it as one
+                        //name to concat the name with.
+                        normalizedBaseParts = baseParts = [baseName];
+                    } else {
+                        //Convert baseName to array, and lop off the last part,
+                        //so that . matches that 'directory' and not name of the baseName's
+                        //module. For instance, baseName of 'one/two/three', maps to
+                        //'one/two/three.js', but we want the directory, 'one/two' for
+                        //this normalization.
+                        normalizedBaseParts = baseParts.slice(0, baseParts.length - 1);
+                    }
+
+                    name = normalizedBaseParts.concat(name.split('/'));
+                    trimDots(name);
+
+                    //Some use of packages may use a . path to reference the
+                    //'main' module name, so normalize for that.
+                    pkgConfig = getOwn(config.pkgs, (pkgName = name[0]));
+                    name = name.join('/');
+                    if (pkgConfig && name === pkgName + '/' + pkgConfig.main) {
+                        name = pkgName;
+                    }
+                } else if (name.indexOf('./') === 0) {
+                    // No baseName, so this is ID is resolved relative
+                    // to baseUrl, pull off the leading dot.
+                    name = name.substring(2);
+                }
+            }
+
+            //Apply map config if available.
+            if (applyMap && map && (baseParts || starMap)) {
+                nameParts = name.split('/');
+
+                for (i = nameParts.length; i > 0; i -= 1) {
+                    nameSegment = nameParts.slice(0, i).join('/');
+
+                    if (baseParts) {
+                        //Find the longest baseName segment match in the config.
+                        //So, do joins on the biggest to smallest lengths of baseParts.
+                        for (j = baseParts.length; j > 0; j -= 1) {
+                            mapValue = getOwn(map, baseParts.slice(0, j).join('/'));
+
+                            //baseName segment has config, find if it has one for
+                            //this name.
+                            if (mapValue) {
+                                mapValue = getOwn(mapValue, nameSegment);
+                                if (mapValue) {
+                                    //Match, update name to the new value.
+                                    foundMap = mapValue;
+                                    foundI = i;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+
+                    if (foundMap) {
+                        break;
+                    }
+
+                    //Check for a star map match, but just hold on to it,
+                    //if there is a shorter segment match later in a matching
+                    //config, then favor over this star map.
+                    if (!foundStarMap && starMap && getOwn(starMap, nameSegment)) {
+                        foundStarMap = getOwn(starMap, nameSegment);
+                        starI = i;
+                    }
+                }
+
+                if (!foundMap && foundStarMap) {
+                    foundMap = foundStarMap;
+                    foundI = starI;
+                }
+
+                if (foundMap) {
+                    nameParts.splice(0, foundI, foundMap);
+                    name = nameParts.join('/');
+                }
+            }
+
+            return name;
+        }
+
+        function removeScript(name) {
+            if (isBrowser) {
+                each(scripts(), function (scriptNode) {
+                    if (scriptNode.getAttribute('data-requiremodule') === name &&
+                            scriptNode.getAttribute('data-requirecontext') === context.contextName) {
+                        scriptNode.parentNode.removeChild(scriptNode);
+                        return true;
+                    }
+                });
+            }
+        }
+
+        function hasPathFallback(id) {
+            var pathConfig = getOwn(config.paths, id);
+            if (pathConfig && isArray(pathConfig) && pathConfig.length > 1) {
+                removeScript(id);
+                //Pop off the first array value, since it failed, and
+                //retry
+                pathConfig.shift();
+                context.require.undef(id);
+                context.require([id]);
+                return true;
+            }
+        }
+
+        //Turns a plugin!resource to [plugin, resource]
+        //with the plugin being undefined if the name
+        //did not have a plugin prefix.
+        function splitPrefix(name) {
+            var prefix,
+                index = name ? name.indexOf('!') : -1;
+            if (index > -1) {
+                prefix = name.substring(0, index);
+                name = name.substring(index + 1, name.length);
+            }
+            return [prefix, name];
+        }
+
+        /**
+         * Creates a module mapping that includes plugin prefix, module
+         * name, and path. If parentModuleMap is provided it will
+         * also normalize the name via require.normalize()
+         *
+         * @param {String} name the module name
+         * @param {String} [parentModuleMap] parent module map
+         * for the module name, used to resolve relative names.
+         * @param {Boolean} isNormalized: is the ID already normalized.
+         * This is true if this call is done for a define() module ID.
+         * @param {Boolean} applyMap: apply the map config to the ID.
+         * Should only be true if this map is for a dependency.
+         *
+         * @returns {Object}
+         */
+        function makeModuleMap(name, parentModuleMap, isNormalized, applyMap) {
+            var url, pluginModule, suffix, nameParts,
+                prefix = null,
+                parentName = parentModuleMap ? parentModuleMap.name : null,
+                originalName = name,
+                isDefine = true,
+                normalizedName = '';
+
+            //If no name, then it means it is a require call, generate an
+            //internal name.
+            if (!name) {
+                isDefine = false;
+                name = '_@r' + (requireCounter += 1);
+            }
+
+            nameParts = splitPrefix(name);
+            prefix = nameParts[0];
+            name = nameParts[1];
+
+            if (prefix) {
+                prefix = normalize(prefix, parentName, applyMap);
+                pluginModule = getOwn(defined, prefix);
+            }
+
+            //Account for relative paths if there is a base name.
+            if (name) {
+                if (prefix) {
+                    if (pluginModule && pluginModule.normalize) {
+                        //Plugin is loaded, use its normalize method.
+                        normalizedName = pluginModule.normalize(name, function (name) {
+                            return normalize(name, parentName, applyMap);
+                        });
+                    } else {
+                        normalizedName = normalize(name, parentName, applyMap);
+                    }
+                } else {
+                    //A regular module.
+                    normalizedName = normalize(name, parentName, applyMap);
+
+                    //Normalized name may be a plugin ID due to map config
+                    //application in normalize. The map config values must
+                    //already be normalized, so do not need to redo that part.
+                    nameParts = splitPrefix(normalizedName);
+                    prefix = nameParts[0];
+                    normalizedName = nameParts[1];
+                    isNormalized = true;
+
+                    url = context.nameToUrl(normalizedName);
+                }
+            }
+
+            //If the id is a plugin id that cannot be determined if it needs
+            //normalization, stamp it with a unique ID so two matching relative
+            //ids that may conflict can be separate.
+            suffix = prefix && !pluginModule && !isNormalized ?
+                     '_unnormalized' + (unnormalizedCounter += 1) :
+                     '';
+
+            return {
+                prefix: prefix,
+                name: normalizedName,
+                parentMap: parentModuleMap,
+                unnormalized: !!suffix,
+                url: url,
+                originalName: originalName,
+                isDefine: isDefine,
+                id: (prefix ?
+                        prefix + '!' + normalizedName :
+                        normalizedName) + suffix
+            };
+        }
+
+        function getModule(depMap) {
+            var id = depMap.id,
+                mod = getOwn(registry, id);
+
+            if (!mod) {
+                mod = registry[id] = new context.Module(depMap);
+            }
+
+            return mod;
+        }
+
+        function on(depMap, name, fn) {
+            var id = depMap.id,
+                mod = getOwn(registry, id);
+
+            if (hasProp(defined, id) &&
+                    (!mod || mod.defineEmitComplete)) {
+                if (name === 'defined') {
+                    fn(defined[id]);
+                }
+            } else {
+                getModule(depMap).on(name, fn);
+            }
+        }
+
+        function onError(err, errback) {
+            var ids = err.requireModules,
+                notified = false;
+
+            if (errback) {
+                errback(err);
+            } else {
+                each(ids, function (id) {
+                    var mod = getOwn(registry, id);
+                    if (mod) {
+                        //Set error on module, so it skips timeout checks.
+                        mod.error = err;
+                        if (mod.events.error) {
+                            notified = true;
+                            mod.emit('error', err);
+                        }
+                    }
+                });
+
+                if (!notified) {
+                    req.onError(err);
+                }
+            }
+        }
+
+        /**
+         * Internal method to transfer globalQueue items to this context's
+         * defQueue.
+         */
+        function takeGlobalQueue() {
+            //Push all the globalDefQueue items into the context's defQueue
+            if (globalDefQueue.length) {
+                //Array splice in the values since the context code has a
+                //local var ref to defQueue, so cannot just reassign the one
+                //on context.
+                apsp.apply(defQueue,
+                           [defQueue.length - 1, 0].concat(globalDefQueue));
+                globalDefQueue = [];
+            }
+        }
+
+        handlers = {
+            'require': function (mod) {
+                if (mod.require) {
+                    return mod.require;
+                } else {
+                    return (mod.require = context.makeRequire(mod.map));
+                }
+            },
+            'exports': function (mod) {
+                mod.usingExports = true;
+                if (mod.map.isDefine) {
+                    if (mod.exports) {
+                        return mod.exports;
+                    } else {
+                        return (mod.exports = defined[mod.map.id] = {});
+                    }
+                }
+            },
+            'module': function (mod) {
+                if (mod.module) {
+                    return mod.module;
+                } else {
+                    return (mod.module = {
+                        id: mod.map.id,
+                        uri: mod.map.url,
+                        config: function () {
+                            return (config.config && getOwn(config.config, mod.map.id)) || {};
+                        },
+                        exports: defined[mod.map.id]
+                    });
+                }
+            }
+        };
+
+        function cleanRegistry(id) {
+            //Clean up machinery used for waiting modules.
+            delete registry[id];
+            delete enabledRegistry[id];
+        }
+
+        function breakCycle(mod, traced, processed) {
+            var id = mod.map.id;
+
+            if (mod.error) {
+                mod.emit('error', mod.error);
+            } else {
+                traced[id] = true;
+                each(mod.depMaps, function (depMap, i) {
+                    var depId = depMap.id,
+                        dep = getOwn(registry, depId);
+
+                    //Only force things that have not completed
+                    //being defined, so still in the registry,
+                    //and only if it has not been matched up
+                    //in the module already.
+                    if (dep && !mod.depMatched[i] && !processed[depId]) {
+                        if (getOwn(traced, depId)) {
+                            mod.defineDep(i, defined[depId]);
+                            mod.check(); //pass false?
+                        } else {
+                            breakCycle(dep, traced, processed);
+                        }
+                    }
+                });
+                processed[id] = true;
+            }
+        }
+
+        function checkLoaded() {
+            var map, modId, err, usingPathFallback,
+                waitInterval = config.waitSeconds * 1000,
+                //It is possible to disable the wait interval by using waitSeconds of 0.
+                expired = waitInterval && (context.startTime + waitInterval) < new Date().getTime(),
+                noLoads = [],
+                reqCalls = [],
+                stillLoading = false,
+                needCycleCheck = true;
+
+            //Do not bother if this call was a result of a cycle break.
+            if (inCheckLoaded) {
+                return;
+            }
+
+            inCheckLoaded = true;
+
+            //Figure out the state of all the modules.
+            eachProp(enabledRegistry, function (mod) {
+                map = mod.map;
+                modId = map.id;
+
+                //Skip things that are not enabled or in error state.
+                if (!mod.enabled) {
+                    return;
+                }
+
+                if (!map.isDefine) {
+                    reqCalls.push(mod);
+                }
+
+                if (!mod.error) {
+                    //If the module should be executed, and it has not
+                    //been inited and time is up, remember it.
+                    if (!mod.inited && expired) {
+                        if (hasPathFallback(modId)) {
+                            usingPathFallback = true;
+                            stillLoading = true;
+                        } else {
+                            noLoads.push(modId);
+                            removeScript(modId);
+                        }
+                    } else if (!mod.inited && mod.fetched && map.isDefine) {
+                        stillLoading = true;
+                        if (!map.prefix) {
+                            //No reason to keep looking for unfinished
+                            //loading. If the only stillLoading is a
+                            //plugin resource though, keep going,
+                            //because it may be that a plugin resource
+                            //is waiting on a non-plugin cycle.
+                            return (needCycleCheck = false);
+                        }
+                    }
+                }
+            });
+
+            if (expired && noLoads.length) {
+                //If wait time expired, throw error of unloaded modules.
+                err = makeError('timeout', 'Load timeout for modules: ' + noLoads, null, noLoads);
+                err.contextName = context.contextName;
+                return onError(err);
+            }
+
+            //Not expired, check for a cycle.
+            if (needCycleCheck) {
+                each(reqCalls, function (mod) {
+                    breakCycle(mod, {}, {});
+                });
+            }
+
+            //If still waiting on loads, and the waiting load is something
+            //other than a plugin resource, or there are still outstanding
+            //scripts, then just try back later.
+            if ((!expired || usingPathFallback) && stillLoading) {
+                //Something is still waiting to load. Wait for it, but only
+                //if a timeout is not already in effect.
+                if ((isBrowser || isWebWorker) && !checkLoadedTimeoutId) {
+                    checkLoadedTimeoutId = setTimeout(function () {
+                        checkLoadedTimeoutId = 0;
+                        checkLoaded();
+                    }, 50);
+                }
+            }
+
+            inCheckLoaded = false;
+        }
+
+        Module = function (map) {
+            this.events = getOwn(undefEvents, map.id) || {};
+            this.map = map;
+            this.shim = getOwn(config.shim, map.id);
+            this.depExports = [];
+            this.depMaps = [];
+            this.depMatched = [];
+            this.pluginMaps = {};
+            this.depCount = 0;
+
+            /* this.exports this.factory
+               this.depMaps = [],
+               this.enabled, this.fetched
+            */
+        };
+
+        Module.prototype = {
+            init: function (depMaps, factory, errback, options) {
+                options = options || {};
+
+                //Do not do more inits if already done. Can happen if there
+                //are multiple define calls for the same module. That is not
+                //a normal, common case, but it is also not unexpected.
+                if (this.inited) {
+                    return;
+                }
+
+                this.factory = factory;
+
+                if (errback) {
+                    //Register for errors on this module.
+                    this.on('error', errback);
+                } else if (this.events.error) {
+                    //If no errback already, but there are error listeners
+                    //on this module, set up an errback to pass to the deps.
+                    errback = bind(this, function (err) {
+                        this.emit('error', err);
+                    });
+                }
+
+                //Do a copy of the dependency array, so that
+                //source inputs are not modified. For example
+                //"shim" deps are passed in here directly, and
+                //doing a direct modification of the depMaps array
+                //would affect that config.
+                this.depMaps = depMaps && depMaps.slice(0);
+
+                this.errback = errback;
+
+                //Indicate this module has be initialized
+                this.inited = true;
+
+                this.ignore = options.ignore;
+
+                //Could have option to init this module in enabled mode,
+                //or could have been previously marked as enabled. However,
+                //the dependencies are not known until init is called. So
+                //if enabled previously, now trigger dependencies as enabled.
+                if (options.enabled || this.enabled) {
+                    //Enable this module and dependencies.
+                    //Will call this.check()
+                    this.enable();
+                } else {
+                    this.check();
+                }
+            },
+
+            defineDep: function (i, depExports) {
+                //Because of cycles, defined callback for a given
+                //export can be called more than once.
+                if (!this.depMatched[i]) {
+                    this.depMatched[i] = true;
+                    this.depCount -= 1;
+                    this.depExports[i] = depExports;
+                }
+            },
+
+            fetch: function () {
+                if (this.fetched) {
+                    return;
+                }
+                this.fetched = true;
+
+                context.startTime = (new Date()).getTime();
+
+                var map = this.map;
+
+                //If the manager is for a plugin managed resource,
+                //ask the plugin to load it now.
+                if (this.shim) {
+                    context.makeRequire(this.map, {
+                        enableBuildCallback: true
+                    })(this.shim.deps || [], bind(this, function () {
+                        return map.prefix ? this.callPlugin() : this.load();
+                    }));
+                } else {
+                    //Regular dependency.
+                    return map.prefix ? this.callPlugin() : this.load();
+                }
+            },
+
+            load: function () {
+                var url = this.map.url;
+
+                //Regular dependency.
+                if (!urlFetched[url]) {
+                    urlFetched[url] = true;
+                    context.load(this.map.id, url);
+                }
+            },
+
+            /**
+             * Checks if the module is ready to define itself, and if so,
+             * define it.
+             */
+            check: function () {
+                if (!this.enabled || this.enabling) {
+                    return;
+                }
+
+                var err, cjsModule,
+                    id = this.map.id,
+                    depExports = this.depExports,
+                    exports = this.exports,
+                    factory = this.factory;
+
+                if (!this.inited) {
+                    this.fetch();
+                } else if (this.error) {
+                    this.emit('error', this.error);
+                } else if (!this.defining) {
+                    //The factory could trigger another require call
+                    //that would result in checking this module to
+                    //define itself again. If already in the process
+                    //of doing that, skip this work.
+                    this.defining = true;
+
+                    if (this.depCount < 1 && !this.defined) {
+                        if (isFunction(factory)) {
+                            //If there is an error listener, favor passing
+                            //to that instead of throwing an error.
+                            if (this.events.error) {
+                                try {
+                                    exports = context.execCb(id, factory, depExports, exports);
+                                } catch (e) {
+                                    err = e;
+                                }
+                            } else {
+                                exports = context.execCb(id, factory, depExports, exports);
+                            }
+
+                            if (this.map.isDefine) {
+                                //If setting exports via 'module' is in play,
+                                //favor that over return value and exports. After that,
+                                //favor a non-undefined return value over exports use.
+                                cjsModule = this.module;
+                                if (cjsModule &&
+                                        cjsModule.exports !== undefined &&
+                                        //Make sure it is not already the exports value
+                                        cjsModule.exports !== this.exports) {
+                                    exports = cjsModule.exports;
+                                } else if (exports === undefined && this.usingExports) {
+                                    //exports already set the defined value.
+                                    exports = this.exports;
+                                }
+                            }
+
+                            if (err) {
+                                err.requireMap = this.map;
+                                err.requireModules = [this.map.id];
+                                err.requireType = 'define';
+                                return onError((this.error = err));
+                            }
+
+                        } else {
+                            //Just a literal value
+                            exports = factory;
+                        }
+
+                        this.exports = exports;
+
+                        if (this.map.isDefine && !this.ignore) {
+                            defined[id] = exports;
+
+                            if (req.onResourceLoad) {
+                                req.onResourceLoad(context, this.map, this.depMaps);
+                            }
+                        }
+
+                        //Clean up
+                        cleanRegistry(id);
+
+                        this.defined = true;
+                    }
+
+                    //Finished the define stage. Allow calling check again
+                    //to allow define notifications below in the case of a
+                    //cycle.
+                    this.defining = false;
+
+                    if (this.defined && !this.defineEmitted) {
+                        this.defineEmitted = true;
+                        this.emit('defined', this.exports);
+                        this.defineEmitComplete = true;
+                    }
+
+                }
+            },
+
+            callPlugin: function () {
+                var map = this.map,
+                    id = map.id,
+                    //Map already normalized the prefix.
+                    pluginMap = makeModuleMap(map.prefix);
+
+                //Mark this as a dependency for this plugin, so it
+                //can be traced for cycles.
+                this.depMaps.push(pluginMap);
+
+                on(pluginMap, 'defined', bind(this, function (plugin) {
+                    var load, normalizedMap, normalizedMod,
+                        name = this.map.name,
+                        parentName = this.map.parentMap ? this.map.parentMap.name : null,
+                        localRequire = context.makeRequire(map.parentMap, {
+                            enableBuildCallback: true
+                        });
+
+                    //If current map is not normalized, wait for that
+                    //normalized name to load instead of continuing.
+                    if (this.map.unnormalized) {
+                        //Normalize the ID if the plugin allows it.
+                        if (plugin.normalize) {
+                            name = plugin.normalize(name, function (name) {
+                                return normalize(name, parentName, true);
+                            }) || '';
+                        }
+
+                        //prefix and name should already be normalized, no need
+                        //for applying map config again either.
+                        normalizedMap = makeModuleMap(map.prefix + '!' + name,
+                                                      this.map.parentMap);
+                        on(normalizedMap,
+                            'defined', bind(this, function (value) {
+                                this.init([], function () { return value; }, null, {
+                                    enabled: true,
+                                    ignore: true
+                                });
+                            }));
+
+                        normalizedMod = getOwn(registry, normalizedMap.id);
+                        if (normalizedMod) {
+                            //Mark this as a dependency for this plugin, so it
+                            //can be traced for cycles.
+                            this.depMaps.push(normalizedMap);
+
+                            if (this.events.error) {
+                                normalizedMod.on('error', bind(this, function (err) {
+                                    this.emit('error', err);
+                                }));
+                            }
+                            normalizedMod.enable();
+                        }
+
+                        return;
+                    }
+
+                    load = bind(this, function (value) {
+                        this.init([], function () { return value; }, null, {
+                            enabled: true
+                        });
+                    });
+
+                    load.error = bind(this, function (err) {
+                        this.inited = true;
+                        this.error = err;
+                        err.requireModules = [id];
+
+                        //Remove temp unnormalized modules for this module,
+                        //since they will never be resolved otherwise now.
+                        eachProp(registry, function (mod) {
+                            if (mod.map.id.indexOf(id + '_unnormalized') === 0) {
+                                cleanRegistry(mod.map.id);
+                            }
+                        });
+
+                        onError(err);
+                    });
+
+                    //Allow plugins to load other code without having to know the
+                    //context or how to 'complete' the load.
+                    load.fromText = bind(this, function (text, textAlt) {
+                        /*jslint evil: true */
+                        var moduleName = map.name,
+                            moduleMap = makeModuleMap(moduleName),
+                            hasInteractive = useInteractive;
+
+                        //As of 2.1.0, support just passing the text, to reinforce
+                        //fromText only being called once per resource. Still
+                        //support old style of passing moduleName but discard
+                        //that moduleName in favor of the internal ref.
+                        if (textAlt) {
+                            text = textAlt;
+                        }
+
+                        //Turn off interactive script matching for IE for any define
+                        //calls in the text, then turn it back on at the end.
+                        if (hasInteractive) {
+                            useInteractive = false;
+                        }
+
+                        //Prime the system by creating a module instance for
+                        //it.
+                        getModule(moduleMap);
+
+                        //Transfer any config to this other module.
+                        if (hasProp(config.config, id)) {
+                            config.config[moduleName] = config.config[id];
+                        }
+
+                        try {
+                            req.exec(text);
+                        } catch (e) {
+                            return onError(makeError('fromtexteval',
+                                             'fromText eval for ' + id +
+                                            ' failed: ' + e,
+                                             e,
+                                             [id]));
+                        }
+
+                        if (hasInteractive) {
+                            useInteractive = true;
+                        }
+
+                        //Mark this as a dependency for the plugin
+                        //resource
+                        this.depMaps.push(moduleMap);
+
+                        //Support anonymous modules.
+                        context.completeLoad(moduleName);
+
+                        //Bind the value of that module to the value for this
+                        //resource ID.
+                        localRequire([moduleName], load);
+                    });
+
+                    //Use parentName here since the plugin's name is not reliable,
+                    //could be some weird string with no path that actually wants to
+                    //reference the parentName's path.
+                    plugin.load(map.name, localRequire, load, config);
+                }));
+
+                context.enable(pluginMap, this);
+                this.pluginMaps[pluginMap.id] = pluginMap;
+            },
+
+            enable: function () {
+                enabledRegistry[this.map.id] = this;
+                this.enabled = true;
+
+                //Set flag mentioning that the module is enabling,
+                //so that immediate calls to the defined callbacks
+                //for dependencies do not trigger inadvertent load
+                //with the depCount still being zero.
+                this.enabling = true;
+
+                //Enable each dependency
+                each(this.depMaps, bind(this, function (depMap, i) {
+                    var id, mod, handler;
+
+                    if (typeof depMap === 'string') {
+                        //Dependency needs to be converted to a depMap
+                        //and wired up to this module.
+                        depMap = makeModuleMap(depMap,
+                                               (this.map.isDefine ? this.map : this.map.parentMap),
+                                               false,
+                                               !this.skipMap);
+                        this.depMaps[i] = depMap;
+
+                        handler = getOwn(handlers, depMap.id);
+
+                        if (handler) {
+                            this.depExports[i] = handler(this);
+                            return;
+                        }
+
+                        this.depCount += 1;
+
+                        on(depMap, 'defined', bind(this, function (depExports) {
+                            this.defineDep(i, depExports);
+                            this.check();
+                        }));
+
+                        if (this.errback) {
+                            on(depMap, 'error', this.errback);
+                        }
+                    }
+
+                    id = depMap.id;
+                    mod = registry[id];
+
+                    //Skip special modules like 'require', 'exports', 'module'
+                    //Also, don't call enable if it is already enabled,
+                    //important in circular dependency cases.
+                    if (!hasProp(handlers, id) && mod && !mod.enabled) {
+                        context.enable(depMap, this);
+                    }
+                }));
+
+                //Enable each plugin that is used in
+                //a dependency
+                eachProp(this.pluginMaps, bind(this, function (pluginMap) {
+                    var mod = getOwn(registry, pluginMap.id);
+                    if (mod && !mod.enabled) {
+                        context.enable(pluginMap, this);
+                    }
+                }));
+
+                this.enabling = false;
+
+                this.check();
+            },
+
+            on: function (name, cb) {
+                var cbs = this.events[name];
+                if (!cbs) {
+                    cbs = this.events[name] = [];
+                }
+                cbs.push(cb);
+            },
+
+            emit: function (name, evt) {
+                each(this.events[name], function (cb) {
+                    cb(evt);
+                });
+                if (name === 'error') {
+                    //Now that the error handler was triggered, remove
+                    //the listeners, since this broken Module instance
+                    //can stay around for a while in the registry.
+                    delete this.events[name];
+                }
+            }
+        };
+
+        function callGetModule(args) {
+            //Skip modules already defined.
+            if (!hasProp(defined, args[0])) {
+                getModule(makeModuleMap(args[0], null, true)).init(args[1], args[2]);
+            }
+        }
+
+        function removeListener(node, func, name, ieName) {
+            //Favor detachEvent because of IE9
+            //issue, see attachEvent/addEventListener comment elsewhere
+            //in this file.
+            if (node.detachEvent && !isOpera) {
+                //Probably IE. If not it will throw an error, which will be
+                //useful to know.
+                if (ieName) {
+                    node.detachEvent(ieName, func);
+                }
+            } else {
+                node.removeEventListener(name, func, false);
+            }
+        }
+
+        /**
+         * Given an event from a script node, get the requirejs info from it,
+         * and then removes the event listeners on the node.
+         * @param {Event} evt
+         * @returns {Object}
+         */
+        function getScriptData(evt) {
+            //Using currentTarget instead of target for Firefox 2.0's sake. Not
+            //all old browsers will be supported, but this one was easy enough
+            //to support and still makes sense.
+            var node = evt.currentTarget || evt.srcElement;
+
+            //Remove the listeners once here.
+            removeListener(node, context.onScriptLoad, 'load', 'onreadystatechange');
+            removeListener(node, context.onScriptError, 'error');
+
+            return {
+                node: node,
+                id: node && node.getAttribute('data-requiremodule')
+            };
+        }
+
+        function intakeDefines() {
+            var args;
+
+            //Any defined modules in the global queue, intake them now.
+            takeGlobalQueue();
+
+            //Make sure any remaining defQueue items get properly processed.
+            while (defQueue.length) {
+                args = defQueue.shift();
+                if (args[0] === null) {
+                    return onError(makeError('mismatch', 'Mismatched anonymous define() module: ' + args[args.length - 1]));
+                } else {
+                    //args are id, deps, factory. Should be normalized by the
+                    //define() function.
+                    callGetModule(args);
+                }
+            }
+        }
+
+        context = {
+            config: config,
+            contextName: contextName,
+            registry: registry,
+            defined: defined,
+            urlFetched: urlFetched,
+            defQueue: defQueue,
+            Module: Module,
+            makeModuleMap: makeModuleMap,
+            nextTick: req.nextTick,
+            onError: onError,
+
+            /**
+             * Set a configuration for the context.
+             * @param {Object} cfg config object to integrate.
+             */
+            configure: function (cfg) {
+                //Make sure the baseUrl ends in a slash.
+                if (cfg.baseUrl) {
+                    if (cfg.baseUrl.charAt(cfg.baseUrl.length - 1) !== '/') {
+                        cfg.baseUrl += '/';
+                    }
+                }
+
+                //Save off the paths and packages since they require special processing,
+                //they are additive.
+                var pkgs = config.pkgs,
+                    shim = config.shim,
+                    objs = {
+                        paths: true,
+                        config: true,
+                        map: true
+                    };
+
+                eachProp(cfg, function (value, prop) {
+                    if (objs[prop]) {
+                        if (prop === 'map') {
+                            if (!config.map) {
+                                config.map = {};
+                            }
+                            mixin(config[prop], value, true, true);
+                        } else {
+                            mixin(config[prop], value, true);
+                        }
+                    } else {
+                        config[prop] = value;
+                    }
+                });
+
+                //Merge shim
+                if (cfg.shim) {
+                    eachProp(cfg.shim, function (value, id) {
+                        //Normalize the structure
+                        if (isArray(value)) {
+                            value = {
+                                deps: value
+                            };
+                        }
+                        if ((value.exports || value.init) && !value.exportsFn) {
+                            value.exportsFn = context.makeShimExports(value);
+                        }
+                        shim[id] = value;
+                    });
+                    config.shim = shim;
+                }
+
+                //Adjust packages if necessary.
+                if (cfg.packages) {
+                    each(cfg.packages, function (pkgObj) {
+                        var location;
+
+                        pkgObj = typeof pkgObj === 'string' ? { name: pkgObj } : pkgObj;
+                        location = pkgObj.location;
+
+                        //Create a brand new object on pkgs, since currentPackages can
+                        //be passed in again, and config.pkgs is the internal transformed
+                        //state for all package configs.
+                        pkgs[pkgObj.name] = {
+                            name: pkgObj.name,
+                            location: location || pkgObj.name,
+                            //Remove leading dot in main, so main paths are normalized,
+                            //and remove any trailing .js, since different package
+                            //envs have different conventions: some use a module name,
+                            //some use a file name.
+                            main: (pkgObj.main || 'main')
+                                  .replace(currDirRegExp, '')
+                                  .replace(jsSuffixRegExp, '')
+                        };
+                    });
+
+                    //Done with modifications, assing packages back to context config
+                    config.pkgs = pkgs;
+                }
+
+                //If there are any "waiting to execute" modules in the registry,
+                //update the maps for them, since their info, like URLs to load,
+                //may have changed.
+                eachProp(registry, function (mod, id) {
+                    //If module already has init called, since it is too
+                    //late to modify them, and ignore unnormalized ones
+                    //since they are transient.
+                    if (!mod.inited && !mod.map.unnormalized) {
+                        mod.map = makeModuleMap(id);
+                    }
+                });
+
+                //If a deps array or a config callback is specified, then call
+                //require with those args. This is useful when require is defined as a
+                //config object before require.js is loaded.
+                if (cfg.deps || cfg.callback) {
+                    context.require(cfg.deps || [], cfg.callback);
+                }
+            },
+
+            makeShimExports: function (value) {
+                function fn() {
+                    var ret;
+                    if (value.init) {
+                        ret = value.init.apply(global, arguments);
+                    }
+                    return ret || (value.exports && getGlobal(value.exports));
+                }
+                return fn;
+            },
+
+            makeRequire: function (relMap, options) {
+                options = options || {};
+
+                function localRequire(deps, callback, errback) {
+                    var id, map, requireMod;
+
+                    if (options.enableBuildCallback && callback && isFunction(callback)) {
+                        callback.__requireJsBuild = true;
+                    }
+
+                    if (typeof deps === 'string') {
+                        if (isFunction(callback)) {
+                            //Invalid call
+                            return onError(makeError('requireargs', 'Invalid require call'), errback);
+                        }
+
+                        //If require|exports|module are requested, get the
+                        //value for them from the special handlers. Caveat:
+                        //this only works while module is being defined.
+                        if (relMap && hasProp(handlers, deps)) {
+                            return handlers[deps](registry[relMap.id]);
+                        }
+
+                        //Synchronous access to one module. If require.get is
+                        //available (as in the Node adapter), prefer that.
+                        if (req.get) {
+                            return req.get(context, deps, relMap, localRequire);
+                        }
+
+                        //Normalize module name, if it contains . or ..
+                        map = makeModuleMap(deps, relMap, false, true);
+                        id = map.id;
+
+                        if (!hasProp(defined, id)) {
+                            return onError(makeError('notloaded', 'Module name "' +
+                                        id +
+                                        '" has not been loaded yet for context: ' +
+                                        contextName +
+                                        (relMap ? '' : '. Use require([])')));
+                        }
+                        return defined[id];
+                    }
+
+                    //Grab defines waiting in the global queue.
+                    intakeDefines();
+
+                    //Mark all the dependencies as needing to be loaded.
+                    context.nextTick(function () {
+                        //Some defines could have been added since the
+                        //require call, collect them.
+                        intakeDefines();
+
+                        requireMod = getModule(makeModuleMap(null, relMap));
+
+                        //Store if map config should be applied to this require
+                        //call for dependencies.
+                        requireMod.skipMap = options.skipMap;
+
+                        requireMod.init(deps, callback, errback, {
+                            enabled: true
+                        });
+
+                        checkLoaded();
+                    });
+
+                    return localRequire;
+                }
+
+                mixin(localRequire, {
+                    isBrowser: isBrowser,
+
+                    /**
+                     * Converts a module name + .extension into an URL path.
+                     * *Requires* the use of a module name. It does not support using
+                     * plain URLs like nameToUrl.
+                     */
+                    toUrl: function (moduleNamePlusExt) {
+                        var ext,
+                            index = moduleNamePlusExt.lastIndexOf('.'),
+                            segment = moduleNamePlusExt.split('/')[0],
+                            isRelative = segment === '.' || segment === '..';
+
+                        //Have a file extension alias, and it is not the
+                        //dots from a relative path.
+                        if (index !== -1 && (!isRelative || index > 1)) {
+                            ext = moduleNamePlusExt.substring(index, moduleNamePlusExt.length);
+                            moduleNamePlusExt = moduleNamePlusExt.substring(0, index);
+                        }
+
+                        return context.nameToUrl(normalize(moduleNamePlusExt,
+                                                relMap && relMap.id, true), ext,  true);
+                    },
+
+                    defined: function (id) {
+                        return hasProp(defined, makeModuleMap(id, relMap, false, true).id);
+                    },
+
+                    specified: function (id) {
+                        id = makeModuleMap(id, relMap, false, true).id;
+                        return hasProp(defined, id) || hasProp(registry, id);
+                    }
+                });
+
+                //Only allow undef on top level require calls
+                if (!relMap) {
+                    localRequire.undef = function (id) {
+                        //Bind any waiting define() calls to this context,
+                        //fix for #408
+                        takeGlobalQueue();
+
+                        var map = makeModuleMap(id, relMap, true),
+                            mod = getOwn(registry, id);
+
+                        delete defined[id];
+                        delete urlFetched[map.url];
+                        delete undefEvents[id];
+
+                        if (mod) {
+                            //Hold on to listeners in case the
+                            //module will be attempted to be reloaded
+                            //using a different config.
+                            if (mod.events.defined) {
+                                undefEvents[id] = mod.events;
+                            }
+
+                            cleanRegistry(id);
+                        }
+                    };
+                }
+
+                return localRequire;
+            },
+
+            /**
+             * Called to enable a module if it is still in the registry
+             * awaiting enablement. A second arg, parent, the parent module,
+             * is passed in for context, when this method is overriden by
+             * the optimizer. Not shown here to keep code compact.
+             */
+            enable: function (depMap) {
+                var mod = getOwn(registry, depMap.id);
+                if (mod) {
+                    getModule(depMap).enable();
+                }
+            },
+
+            /**
+             * Internal method used by environment adapters to complete a load event.
+             * A load event could be a script load or just a load pass from a synchronous
+             * load call.
+             * @param {String} moduleName the name of the module to potentially complete.
+             */
+            completeLoad: function (moduleName) {
+                var found, args, mod,
+                    shim = getOwn(config.shim, moduleName) || {},
+                    shExports = shim.exports;
+
+                takeGlobalQueue();
+
+                while (defQueue.length) {
+                    args = defQueue.shift();
+                    if (args[0] === null) {
+                        args[0] = moduleName;
+                        //If already found an anonymous module and bound it
+                        //to this name, then this is some other anon module
+                        //waiting for its completeLoad to fire.
+                        if (found) {
+                            break;
+                        }
+                        found = true;
+                    } else if (args[0] === moduleName) {
+                        //Found matching define call for this script!
+                        found = true;
+                    }
+
+                    callGetModule(args);
+                }
+
+                //Do this after the cycle of callGetModule in case the result
+                //of those calls/init calls changes the registry.
+                mod = getOwn(registry, moduleName);
+
+                if (!found && !hasProp(defined, moduleName) && mod && !mod.inited) {
+                    if (config.enforceDefine && (!shExports || !getGlobal(shExports))) {
+                        if (hasPathFallback(moduleName)) {
+                            return;
+                        } else {
+                            return onError(makeError('nodefine',
+                                             'No define call for ' + moduleName,
+                                             null,
+                                             [moduleName]));
+                        }
+                    } else {
+                        //A script that does not call define(), so just simulate
+                        //the call for it.
+                        callGetModule([moduleName, (shim.deps || []), shim.exportsFn]);
+                    }
+                }
+
+                checkLoaded();
+            },
+
+            /**
+             * Converts a module name to a file path. Supports cases where
+             * moduleName may actually be just an URL.
+             * Note that it **does not** call normalize on the moduleName,
+             * it is assumed to have already been normalized. This is an
+             * internal API, not a public one. Use toUrl for the public API.
+             */
+            nameToUrl: function (moduleName, ext, skipExt) {
+                var paths, pkgs, pkg, pkgPath, syms, i, parentModule, url,
+                    parentPath;
+
+                //If a colon is in the URL, it indicates a protocol is used and it is just
+                //an URL to a file, or if it starts with a slash, contains a query arg (i.e. ?)
+                //or ends with .js, then assume the user meant to use an url and not a module id.
+                //The slash is important for protocol-less URLs as well as full paths.
+                if (req.jsExtRegExp.test(moduleName)) {
+                    //Just a plain path, not module name lookup, so just return it.
+                    //Add extension if it is included. This is a bit wonky, only non-.js things pass
+                    //an extension, this method probably needs to be reworked.
+                    url = moduleName + (ext || '');
+                } else {
+                    //A module that needs to be converted to a path.
+                    paths = config.paths;
+                    pkgs = config.pkgs;
+
+                    syms = moduleName.split('/');
+                    //For each module name segment, see if there is a path
+                    //registered for it. Start with most specific name
+                    //and work up from it.
+                    for (i = syms.length; i > 0; i -= 1) {
+                        parentModule = syms.slice(0, i).join('/');
+                        pkg = getOwn(pkgs, parentModule);
+                        parentPath = getOwn(paths, parentModule);
+                        if (parentPath) {
+                            //If an array, it means there are a few choices,
+                            //Choose the one that is desired
+                            if (isArray(parentPath)) {
+                                parentPath = parentPath[0];
+                            }
+                            syms.splice(0, i, parentPath);
+                            break;
+                        } else if (pkg) {
+                            //If module name is just the package name, then looking
+                            //for the main module.
+                            if (moduleName === pkg.name) {
+                                pkgPath = pkg.location + '/' + pkg.main;
+                            } else {
+                                pkgPath = pkg.location;
+                            }
+                            syms.splice(0, i, pkgPath);
+                            break;
+                        }
+                    }
+
+                    //Join the path parts together, then figure out if baseUrl is needed.
+                    url = syms.join('/');
+                    url += (ext || (/\?/.test(url) || skipExt ? '' : '.js'));
+                    url = (url.charAt(0) === '/' || url.match(/^[\w\+\.\-]+:/) ? '' : config.baseUrl) + url;
+                }
+
+                return config.urlArgs ? url +
+                                        ((url.indexOf('?') === -1 ? '?' : '&') +
+                                         config.urlArgs) : url;
+            },
+
+            //Delegates to req.load. Broken out as a separate function to
+            //allow overriding in the optimizer.
+            load: function (id, url) {
+                req.load(context, id, url);
+            },
+
+            /**
+             * Executes a module callack function. Broken out as a separate function
+             * solely to allow the build system to sequence the files in the built
+             * layer in the right sequence.
+             *
+             * @private
+             */
+            execCb: function (name, callback, args, exports) {
+                return callback.apply(exports, args);
+            },
+
+            /**
+             * callback for script loads, used to check status of loading.
+             *
+             * @param {Event} evt the event from the browser for the script
+             * that was loaded.
+             */
+            onScriptLoad: function (evt) {
+                //Using currentTarget instead of target for Firefox 2.0's sake. Not
+                //all old browsers will be supported, but this one was easy enough
+                //to support and still makes sense.
+                if (evt.type === 'load' ||
+                        (readyRegExp.test((evt.currentTarget || evt.srcElement).readyState))) {
+                    //Reset interactive script so a script node is not held onto for
+                    //to long.
+                    interactiveScript = null;
+
+                    //Pull out the name of the module and the context.
+                    var data = getScriptData(evt);
+                    context.completeLoad(data.id);
+                }
+            },
+
+            /**
+             * Callback for script errors.
+             */
+            onScriptError: function (evt) {
+                var data = getScriptData(evt);
+                if (!hasPathFallback(data.id)) {
+                    return onError(makeError('scripterror', 'Script error', evt, [data.id]));
+                }
+            }
+        };
+
+        context.require = context.makeRequire();
+        return context;
+    }
+
+    /**
+     * Main entry point.
+     *
+     * If the only argument to require is a string, then the module that
+     * is represented by that string is fetched for the appropriate context.
+     *
+     * If the first argument is an array, then it will be treated as an array
+     * of dependency string names to fetch. An optional function callback can
+     * be specified to execute when all of those dependencies are available.
+     *
+     * Make a local req variable to help Caja compliance (it assumes things
+     * on a require that are not standardized), and to give a short
+     * name for minification/local scope use.
+     */
+    req = requirejs = function (deps, callback, errback, optional) {
+
+        //Find the right context, use default
+        var context, config,
+            contextName = defContextName;
+
+        // Determine if have config object in the call.
+        if (!isArray(deps) && typeof deps !== 'string') {
+            // deps is a config object
+            config = deps;
+            if (isArray(callback)) {
+                // Adjust args if there are dependencies
+                deps = callback;
+                callback = errback;
+                errback = optional;
+            } else {
+                deps = [];
+            }
+        }
+
+        if (config && config.context) {
+            contextName = config.context;
+        }
+
+        context = getOwn(contexts, contextName);
+        if (!context) {
+            context = contexts[contextName] = req.s.newContext(contextName);
+        }
+
+        if (config) {
+            context.configure(config);
+        }
+
+        return context.require(deps, callback, errback);
+    };
+
+    /**
+     * Support require.config() to make it easier to cooperate with other
+     * AMD loaders on globally agreed names.
+     */
+    req.config = function (config) {
+        return req(config);
+    };
+
+    /**
+     * Execute something after the current tick
+     * of the event loop. Override for other envs
+     * that have a better solution than setTimeout.
+     * @param  {Function} fn function to execute later.
+     */
+    req.nextTick = typeof setTimeout !== 'undefined' ? function (fn) {
+        setTimeout(fn, 4);
+    } : function (fn) { fn(); };
+
+    /**
+     * Export require as a global, but only if it does not already exist.
+     */
+    if (!require) {
+        require = req;
+    }
+
+    req.version = version;
+
+    //Used to filter out dependencies that are already paths.
+    req.jsExtRegExp = /^\/|:|\?|\.js$/;
+    req.isBrowser = isBrowser;
+    s = req.s = {
+        contexts: contexts,
+        newContext: newContext
+    };
+
+    //Create default context.
+    req({});
+
+    //Exports some context-sensitive methods on global require.
+    each([
+        'toUrl',
+        'undef',
+        'defined',
+        'specified'
+    ], function (prop) {
+        //Reference from contexts instead of early binding to default context,
+        //so that during builds, the latest instance of the default context
+        //with its config gets used.
+        req[prop] = function () {
+            var ctx = contexts[defContextName];
+            return ctx.require[prop].apply(ctx, arguments);
+        };
+    });
+
+    if (isBrowser) {
+        head = s.head = document.getElementsByTagName('head')[0];
+        //If BASE tag is in play, using appendChild is a problem for IE6.
+        //When that browser dies, this can be removed. Details in this jQuery bug:
+        //http://dev.jquery.com/ticket/2709
+        baseElement = document.getElementsByTagName('base')[0];
+        if (baseElement) {
+            head = s.head = baseElement.parentNode;
+        }
+    }
+
+    /**
+     * Any errors that require explicitly generates will be passed to this
+     * function. Intercept/override it if you want custom error handling.
+     * @param {Error} err the error object.
+     */
+    req.onError = function (err) {
+        throw err;
+    };
+
+    /**
+     * Does the request to load a module for the browser case.
+     * Make this a separate function to allow other environments
+     * to override it.
+     *
+     * @param {Object} context the require context to find state.
+     * @param {String} moduleName the name of the module.
+     * @param {Object} url the URL to the module.
+     */
+    req.load = function (context, moduleName, url) {
+        var config = (context && context.config) || {},
+            node;
+        if (isBrowser) {
+            //In the browser so use a script tag
+            node = config.xhtml ?
+                    document.createElementNS('http://www.w3.org/1999/xhtml', 'html:script') :
+                    document.createElement('script');
+            node.type = config.scriptType || 'text/javascript';
+            node.charset = 'utf-8';
+            node.async = true;
+
+            node.setAttribute('data-requirecontext', context.contextName);
+            node.setAttribute('data-requiremodule', moduleName);
+
+            //Set up load listener. Test attachEvent first because IE9 has
+            //a subtle issue in its addEventListener and script onload firings
+            //that do not match the behavior of all other browsers with
+            //addEventListener support, which fire the onload event for a
+            //script right after the script execution. See:
+            //https://connect.microsoft.com/IE/feedback/details/648057/script-onload-event-is-not-fired-immediately-after-script-execution
+            //UNFORTUNATELY Opera implements attachEvent but does not follow the script
+            //script execution mode.
+            if (node.attachEvent &&
+                    //Check if node.attachEvent is artificially added by custom script or
+                    //natively supported by browser
+                    //read https://github.com/jrburke/requirejs/issues/187
+                    //if we can NOT find [native code] then it must NOT natively supported.
+                    //in IE8, node.attachEvent does not have toString()
+                    //Note the test for "[native code" with no closing brace, see:
+                    //https://github.com/jrburke/requirejs/issues/273
+                    !(node.attachEvent.toString && node.attachEvent.toString().indexOf('[native code') < 0) &&
+                    !isOpera) {
+                //Probably IE. IE (at least 6-8) do not fire
+                //script onload right after executing the script, so
+                //we cannot tie the anonymous define call to a name.
+                //However, IE reports the script as being in 'interactive'
+                //readyState at the time of the define call.
+                useInteractive = true;
+
+                node.attachEvent('onreadystatechange', context.onScriptLoad);
+                //It would be great to add an error handler here to catch
+                //404s in IE9+. However, onreadystatechange will fire before
+                //the error handler, so that does not help. If addEventListener
+                //is used, then IE will fire error before load, but we cannot
+                //use that pathway given the connect.microsoft.com issue
+                //mentioned above about not doing the 'script execute,
+                //then fire the script load event listener before execute
+                //next script' that other browsers do.
+                //Best hope: IE10 fixes the issues,
+                //and then destroys all installs of IE 6-9.
+                //node.attachEvent('onerror', context.onScriptError);
+            } else {
+                node.addEventListener('load', context.onScriptLoad, false);
+                node.addEventListener('error', context.onScriptError, false);
+            }
+            node.src = url;
+
+            //For some cache cases in IE 6-8, the script executes before the end
+            //of the appendChild execution, so to tie an anonymous define
+            //call to the module name (which is stored on the node), hold on
+            //to a reference to this node, but clear after the DOM insertion.
+            currentlyAddingScript = node;
+            if (baseElement) {
+                head.insertBefore(node, baseElement);
+            } else {
+                head.appendChild(node);
+            }
+            currentlyAddingScript = null;
+
+            return node;
+        } else if (isWebWorker) {
+            try {
+                //In a web worker, use importScripts. This is not a very
+                //efficient use of importScripts, importScripts will block until
+                //its script is downloaded and evaluated. However, if web workers
+                //are in play, the expectation that a build has been done so that
+                //only one script needs to be loaded anyway. This may need to be
+                //reevaluated if other use cases become common.
+                importScripts(url);
+
+                //Account for anonymous modules
+                context.completeLoad(moduleName);
+            } catch (e) {
+                context.onError(makeError('importscripts',
+                                'importScripts failed for ' +
+                                    moduleName + ' at ' + url,
+                                e,
+                                [moduleName]));
+            }
+        }
+    };
+
+    function getInteractiveScript() {
+        if (interactiveScript && interactiveScript.readyState === 'interactive') {
+            return interactiveScript;
+        }
+
+        eachReverse(scripts(), function (script) {
+            if (script.readyState === 'interactive') {
+                return (interactiveScript = script);
+            }
+        });
+        return interactiveScript;
+    }
+
+    //Look for a data-main script attribute, which could also adjust the baseUrl.
+    if (isBrowser) {
+        //Figure out baseUrl. Get it from the script tag with require.js in it.
+        eachReverse(scripts(), function (script) {
+            //Set the 'head' where we can append children by
+            //using the script's parent.
+            if (!head) {
+                head = script.parentNode;
+            }
+
+            //Look for a data-main attribute to set main script for the page
+            //to load. If it is there, the path to data main becomes the
+            //baseUrl, if it is not already set.
+            dataMain = script.getAttribute('data-main');
+            if (dataMain) {
+                //Set final baseUrl if there is not already an explicit one.
+                if (!cfg.baseUrl) {
+                    //Pull off the directory of data-main for use as the
+                    //baseUrl.
+                    src = dataMain.split('/');
+                    mainScript = src.pop();
+                    subPath = src.length ? src.join('/')  + '/' : './';
+
+                    cfg.baseUrl = subPath;
+                    dataMain = mainScript;
+                }
+
+                //Strip off any trailing .js since dataMain is now
+                //like a module name.
+                dataMain = dataMain.replace(jsSuffixRegExp, '');
+
+                //Put the data-main script in the files to load.
+                cfg.deps = cfg.deps ? cfg.deps.concat(dataMain) : [dataMain];
+
+                return true;
+            }
+        });
+    }
+
+    /**
+     * The function that handles definitions of modules. Differs from
+     * require() in that a string for the module should be the first argument,
+     * and the function to execute after dependencies are loaded should
+     * return a value to define the module corresponding to the first argument's
+     * name.
+     */
+    define = function (name, deps, callback) {
+        var node, context;
+
+        //Allow for anonymous modules
+        if (typeof name !== 'string') {
+            //Adjust args appropriately
+            callback = deps;
+            deps = name;
+            name = null;
+        }
+
+        //This module may not have dependencies
+        if (!isArray(deps)) {
+            callback = deps;
+            deps = [];
+        }
+
+        //If no name, and callback is a function, then figure out if it a
+        //CommonJS thing with dependencies.
+        if (!deps.length && isFunction(callback)) {
+            //Remove comments from the callback string,
+            //look for require calls, and pull them into the dependencies,
+            //but only if there are function args.
+            if (callback.length) {
+                callback
+                    .toString()
+                    .replace(commentRegExp, '')
+                    .replace(cjsRequireRegExp, function (match, dep) {
+                        deps.push(dep);
+                    });
+
+                //May be a CommonJS thing even without require calls, but still
+                //could use exports, and module. Avoid doing exports and module
+                //work though if it just needs require.
+                //REQUIRES the function to expect the CommonJS variables in the
+                //order listed below.
+                deps = (callback.length === 1 ? ['require'] : ['require', 'exports', 'module']).concat(deps);
+            }
+        }
+
+        //If in IE 6-8 and hit an anonymous define() call, do the interactive
+        //work.
+        if (useInteractive) {
+            node = currentlyAddingScript || getInteractiveScript();
+            if (node) {
+                if (!name) {
+                    name = node.getAttribute('data-requiremodule');
+                }
+                context = contexts[node.getAttribute('data-requirecontext')];
+            }
+        }
+
+        //Always save off evaluating the def call until the script onload handler.
+        //This allows multiple modules to be in a file without prematurely
+        //tracing dependencies, and allows for anonymous module support,
+        //where the module name is not known until the script onload event
+        //occurs. If no context, use the global queue, and get it processed
+        //in the onscript load callback.
+        (context ? context.defQueue : globalDefQueue).push([name, deps, callback]);
+    };
+
+    define.amd = {
+        jQuery: true
+    };
+
+
+    /**
+     * Executes the text. Normally just uses eval, but can be modified
+     * to use a better, environment-specific call. Only used for transpiling
+     * loader plugins, not for plain JS modules.
+     * @param {String} text the text to execute/evaluate.
+     */
+    req.exec = function (text) {
+        /*jslint evil: true */
+        return eval(text);
+    };
+
+    //Set up with config info.
+    req(cfg);
+}(this));
diff --git a/module/web/static/js/libs/select2-3.3.1.js b/module/web/static/js/libs/select2-3.3.1.js
new file mode 100644
index 000000000..8be2c7e9f
--- /dev/null
+++ b/module/web/static/js/libs/select2-3.3.1.js
@@ -0,0 +1,2711 @@
+/*
+Copyright 2012 Igor Vaynberg
+
+Version: 3.3.1 Timestamp: Wed Feb 20 09:57:22 PST 2013
+
+This software is licensed under the Apache License, Version 2.0 (the "Apache License") or the GNU
+General Public License version 2 (the "GPL License"). You may choose either license to govern your
+use of this software only upon the condition that you accept all of the terms of either the Apache
+License or the GPL License.
+
+You may obtain a copy of the Apache License and the GPL License at:
+
+    http://www.apache.org/licenses/LICENSE-2.0
+    http://www.gnu.org/licenses/gpl-2.0.html
+
+Unless required by applicable law or agreed to in writing, software distributed under the
+Apache License or the GPL Licesnse is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied. See the Apache License and the GPL License for
+the specific language governing permissions and limitations under the Apache License and the GPL License.
+*/
+ (function ($) {
+ 	if(typeof $.fn.each2 == "undefined"){
+ 		$.fn.extend({
+ 			/*
+			* 4-10 times faster .each replacement
+			* use it carefully, as it overrides jQuery context of element on each iteration
+			*/
+			each2 : function (c) {
+				var j = $([0]), i = -1, l = this.length;
+				while (
+					++i < l
+					&& (j.context = j[0] = this[i])
+					&& c.call(j[0], i, j) !== false //"this"=DOM, i=index, j=jQuery object
+				);
+				return this;
+			}
+ 		});
+ 	}
+})(jQuery);
+
+(function ($, undefined) {
+    "use strict";
+    /*global document, window, jQuery, console */
+
+    if (window.Select2 !== undefined) {
+        return;
+    }
+
+    var KEY, AbstractSelect2, SingleSelect2, MultiSelect2, nextUid, sizer,
+        lastMousePosition, $document;
+
+    KEY = {
+        TAB: 9,
+        ENTER: 13,
+        ESC: 27,
+        SPACE: 32,
+        LEFT: 37,
+        UP: 38,
+        RIGHT: 39,
+        DOWN: 40,
+        SHIFT: 16,
+        CTRL: 17,
+        ALT: 18,
+        PAGE_UP: 33,
+        PAGE_DOWN: 34,
+        HOME: 36,
+        END: 35,
+        BACKSPACE: 8,
+        DELETE: 46,
+        isArrow: function (k) {
+            k = k.which ? k.which : k;
+            switch (k) {
+            case KEY.LEFT:
+            case KEY.RIGHT:
+            case KEY.UP:
+            case KEY.DOWN:
+                return true;
+            }
+            return false;
+        },
+        isControl: function (e) {
+            var k = e.which;
+            switch (k) {
+            case KEY.SHIFT:
+            case KEY.CTRL:
+            case KEY.ALT:
+                return true;
+            }
+
+            if (e.metaKey) return true;
+
+            return false;
+        },
+        isFunctionKey: function (k) {
+            k = k.which ? k.which : k;
+            return k >= 112 && k <= 123;
+        }
+    };
+
+    $document = $(document);
+
+    nextUid=(function() { var counter=1; return function() { return counter++; }; }());
+
+    function indexOf(value, array) {
+        var i = 0, l = array.length;
+        for (; i < l; i = i + 1) {
+            if (equal(value, array[i])) return i;
+        }
+        return -1;
+    }
+
+    /**
+     * Compares equality of a and b
+     * @param a
+     * @param b
+     */
+    function equal(a, b) {
+        if (a === b) return true;
+        if (a === undefined || b === undefined) return false;
+        if (a === null || b === null) return false;
+        if (a.constructor === String) return a === b+'';
+        if (b.constructor === String) return b === a+'';
+        return false;
+    }
+
+    /**
+     * Splits the string into an array of values, trimming each value. An empty array is returned for nulls or empty
+     * strings
+     * @param string
+     * @param separator
+     */
+    function splitVal(string, separator) {
+        var val, i, l;
+        if (string === null || string.length < 1) return [];
+        val = string.split(separator);
+        for (i = 0, l = val.length; i < l; i = i + 1) val[i] = $.trim(val[i]);
+        return val;
+    }
+
+    function getSideBorderPadding(element) {
+        return element.outerWidth(false) - element.width();
+    }
+
+    function installKeyUpChangeEvent(element) {
+        var key="keyup-change-value";
+        element.bind("keydown", function () {
+            if ($.data(element, key) === undefined) {
+                $.data(element, key, element.val());
+            }
+        });
+        element.bind("keyup", function () {
+            var val= $.data(element, key);
+            if (val !== undefined && element.val() !== val) {
+                $.removeData(element, key);
+                element.trigger("keyup-change");
+            }
+        });
+    }
+
+    $document.bind("mousemove", function (e) {
+        lastMousePosition = {x: e.pageX, y: e.pageY};
+    });
+
+    /**
+     * filters mouse events so an event is fired only if the mouse moved.
+     *
+     * filters out mouse events that occur when mouse is stationary but
+     * the elements under the pointer are scrolled.
+     */
+    function installFilteredMouseMove(element) {
+	    element.bind("mousemove", function (e) {
+            var lastpos = lastMousePosition;
+            if (lastpos === undefined || lastpos.x !== e.pageX || lastpos.y !== e.pageY) {
+                $(e.target).trigger("mousemove-filtered", e);
+            }
+        });
+    }
+
+    /**
+     * Debounces a function. Returns a function that calls the original fn function only if no invocations have been made
+     * within the last quietMillis milliseconds.
+     *
+     * @param quietMillis number of milliseconds to wait before invoking fn
+     * @param fn function to be debounced
+     * @param ctx object to be used as this reference within fn
+     * @return debounced version of fn
+     */
+    function debounce(quietMillis, fn, ctx) {
+        ctx = ctx || undefined;
+        var timeout;
+        return function () {
+            var args = arguments;
+            window.clearTimeout(timeout);
+            timeout = window.setTimeout(function() {
+                fn.apply(ctx, args);
+            }, quietMillis);
+        };
+    }
+
+    /**
+     * A simple implementation of a thunk
+     * @param formula function used to lazily initialize the thunk
+     * @return {Function}
+     */
+    function thunk(formula) {
+        var evaluated = false,
+            value;
+        return function() {
+            if (evaluated === false) { value = formula(); evaluated = true; }
+            return value;
+        };
+    };
+
+    function installDebouncedScroll(threshold, element) {
+        var notify = debounce(threshold, function (e) { element.trigger("scroll-debounced", e);});
+        element.bind("scroll", function (e) {
+            if (indexOf(e.target, element.get()) >= 0) notify(e);
+        });
+    }
+
+    function focus($el) {
+        if ($el[0] === document.activeElement) return;
+
+        /* set the focus in a 0 timeout - that way the focus is set after the processing
+            of the current event has finished - which seems like the only reliable way
+            to set focus */
+        window.setTimeout(function() {
+            var el=$el[0], pos=$el.val().length, range;
+
+            $el.focus();
+
+            /* after the focus is set move the caret to the end, necessary when we val()
+                just before setting focus */
+            if(el.setSelectionRange)
+            {
+                el.setSelectionRange(pos, pos);
+            }
+            else if (el.createTextRange) {
+                range = el.createTextRange();
+                range.collapse(true);
+                range.moveEnd('character', pos);
+                range.moveStart('character', pos);
+                range.select();
+            }
+
+        }, 0);
+    }
+
+    function killEvent(event) {
+        event.preventDefault();
+        event.stopPropagation();
+    }
+    function killEventImmediately(event) {
+        event.preventDefault();
+        event.stopImmediatePropagation();
+    }
+
+    function measureTextWidth(e) {
+        if (!sizer){
+        	var style = e[0].currentStyle || window.getComputedStyle(e[0], null);
+        	sizer = $(document.createElement("div")).css({
+	            position: "absolute",
+	            left: "-10000px",
+	            top: "-10000px",
+	            display: "none",
+	            fontSize: style.fontSize,
+	            fontFamily: style.fontFamily,
+	            fontStyle: style.fontStyle,
+	            fontWeight: style.fontWeight,
+	            letterSpacing: style.letterSpacing,
+	            textTransform: style.textTransform,
+	            whiteSpace: "nowrap"
+	        });
+            sizer.attr("class","select2-sizer");
+        	$("body").append(sizer);
+        }
+        sizer.text(e.val());
+        return sizer.width();
+    }
+
+    function syncCssClasses(dest, src, adapter) {
+        var classes, replacements = [], adapted;
+
+        classes = dest.attr("class");
+        if (typeof classes === "string") {
+            $(classes.split(" ")).each2(function() {
+                if (this.indexOf("select2-") === 0) {
+                    replacements.push(this);
+                }
+            });
+        }
+        classes = src.attr("class");
+        if (typeof classes === "string") {
+            $(classes.split(" ")).each2(function() {
+                if (this.indexOf("select2-") !== 0) {
+                    adapted = adapter(this);
+                    if (typeof adapted === "string" && adapted.length > 0) {
+                        replacements.push(this);
+                    }
+                }
+            });
+        }
+        dest.attr("class", replacements.join(" "));
+    }
+
+
+    function markMatch(text, term, markup, escapeMarkup) {
+        var match=text.toUpperCase().indexOf(term.toUpperCase()),
+            tl=term.length;
+
+        if (match<0) {
+            markup.push(escapeMarkup(text));
+            return;
+        }
+
+        markup.push(escapeMarkup(text.substring(0, match)));
+        markup.push("<span class='select2-match'>");
+        markup.push(escapeMarkup(text.substring(match, match + tl)));
+        markup.push("</span>");
+        markup.push(escapeMarkup(text.substring(match + tl, text.length)));
+    }
+
+    /**
+     * Produces an ajax-based query function
+     *
+     * @param options object containing configuration paramters
+     * @param options.transport function that will be used to execute the ajax request. must be compatible with parameters supported by $.ajax
+     * @param options.url url for the data
+     * @param options.data a function(searchTerm, pageNumber, context) that should return an object containing query string parameters for the above url.
+     * @param options.dataType request data type: ajax, jsonp, other datatatypes supported by jQuery's $.ajax function or the transport function if specified
+     * @param options.traditional a boolean flag that should be true if you wish to use the traditional style of param serialization for the ajax request
+     * @param options.quietMillis (optional) milliseconds to wait before making the ajaxRequest, helps debounce the ajax function if invoked too often
+     * @param options.results a function(remoteData, pageNumber) that converts data returned form the remote request to the format expected by Select2.
+     *      The expected format is an object containing the following keys:
+     *      results array of objects that will be used as choices
+     *      more (optional) boolean indicating whether there are more results available
+     *      Example: {results:[{id:1, text:'Red'},{id:2, text:'Blue'}], more:true}
+     */
+    function ajax(options) {
+        var timeout, // current scheduled but not yet executed request
+            requestSequence = 0, // sequence used to drop out-of-order responses
+            handler = null,
+            quietMillis = options.quietMillis || 100,
+            ajaxUrl = options.url,
+            self = this;
+
+        return function (query) {
+            window.clearTimeout(timeout);
+            timeout = window.setTimeout(function () {
+                requestSequence += 1; // increment the sequence
+                var requestNumber = requestSequence, // this request's sequence number
+                    data = options.data, // ajax data function
+                    url = ajaxUrl, // ajax url string or function
+                    transport = options.transport || $.ajax,
+                    type = options.type || 'GET', // set type of request (GET or POST)
+                    params = {};
+
+                data = data ? data.call(self, query.term, query.page, query.context) : null;
+                url = (typeof url === 'function') ? url.call(self, query.term, query.page, query.context) : url;
+
+                if( null !== handler) { handler.abort(); }
+
+                if (options.params) {
+                    if ($.isFunction(options.params)) {
+                        $.extend(params, options.params.call(self));
+                    } else {
+                        $.extend(params, options.params);
+                    }
+                }
+
+                $.extend(params, {
+                    url: url,
+                    dataType: options.dataType,
+                    data: data,
+                    type: type,
+                    cache: false,
+                    success: function (data) {
+                        if (requestNumber < requestSequence) {
+                            return;
+                        }
+                        // TODO - replace query.page with query so users have access to term, page, etc.
+                        var results = options.results(data, query.page);
+                        query.callback(results);
+                    }
+                });
+                handler = transport.call(self, params);
+            }, quietMillis);
+        };
+    }
+
+    /**
+     * Produces a query function that works with a local array
+     *
+     * @param options object containing configuration parameters. The options parameter can either be an array or an
+     * object.
+     *
+     * If the array form is used it is assumed that it contains objects with 'id' and 'text' keys.
+     *
+     * If the object form is used ti is assumed that it contains 'data' and 'text' keys. The 'data' key should contain
+     * an array of objects that will be used as choices. These objects must contain at least an 'id' key. The 'text'
+     * key can either be a String in which case it is expected that each element in the 'data' array has a key with the
+     * value of 'text' which will be used to match choices. Alternatively, text can be a function(item) that can extract
+     * the text.
+     */
+    function local(options) {
+        var data = options, // data elements
+            dataText,
+            tmp,
+            text = function (item) { return ""+item.text; }; // function used to retrieve the text portion of a data item that is matched against the search
+
+		 if ($.isArray(data)) {
+            tmp = data;
+            data = { results: tmp };
+        }
+
+		 if ($.isFunction(data) === false) {
+            tmp = data;
+            data = function() { return tmp; };
+        }
+
+        var dataItem = data();
+        if (dataItem.text) {
+            text = dataItem.text;
+            // if text is not a function we assume it to be a key name
+            if (!$.isFunction(text)) {
+                dataText = data.text; // we need to store this in a separate variable because in the next step data gets reset and data.text is no longer available
+                text = function (item) { return item[dataText]; };
+            }
+        }
+
+        return function (query) {
+            var t = query.term, filtered = { results: [] }, process;
+            if (t === "") {
+                query.callback(data());
+                return;
+            }
+
+            process = function(datum, collection) {
+                var group, attr;
+                datum = datum[0];
+                if (datum.children) {
+                    group = {};
+                    for (attr in datum) {
+                        if (datum.hasOwnProperty(attr)) group[attr]=datum[attr];
+                    }
+                    group.children=[];
+                    $(datum.children).each2(function(i, childDatum) { process(childDatum, group.children); });
+                    if (group.children.length || query.matcher(t, text(group), datum)) {
+                        collection.push(group);
+                    }
+                } else {
+                    if (query.matcher(t, text(datum), datum)) {
+                        collection.push(datum);
+                    }
+                }
+            };
+
+            $(data().results).each2(function(i, datum) { process(datum, filtered.results); });
+            query.callback(filtered);
+        };
+    }
+
+    // TODO javadoc
+    function tags(data) {
+        var isFunc = $.isFunction(data);
+        return function (query) {
+            var t = query.term, filtered = {results: []};
+            $(isFunc ? data() : data).each(function () {
+                var isObject = this.text !== undefined,
+                    text = isObject ? this.text : this;
+                if (t === "" || query.matcher(t, text)) {
+                    filtered.results.push(isObject ? this : {id: this, text: this});
+                }
+            });
+            query.callback(filtered);
+        };
+    }
+
+    /**
+     * Checks if the formatter function should be used.
+     *
+     * Throws an error if it is not a function. Returns true if it should be used,
+     * false if no formatting should be performed.
+     *
+     * @param formatter
+     */
+    function checkFormatter(formatter, formatterName) {
+        if ($.isFunction(formatter)) return true;
+        if (!formatter) return false;
+        throw new Error("formatterName must be a function or a falsy value");
+    }
+
+    function evaluate(val) {
+        return $.isFunction(val) ? val() : val;
+    }
+
+    function countResults(results) {
+        var count = 0;
+        $.each(results, function(i, item) {
+            if (item.children) {
+                count += countResults(item.children);
+            } else {
+                count++;
+            }
+        });
+        return count;
+    }
+
+    /**
+     * Default tokenizer. This function uses breaks the input on substring match of any string from the
+     * opts.tokenSeparators array and uses opts.createSearchChoice to create the choice object. Both of those
+     * two options have to be defined in order for the tokenizer to work.
+     *
+     * @param input text user has typed so far or pasted into the search field
+     * @param selection currently selected choices
+     * @param selectCallback function(choice) callback tho add the choice to selection
+     * @param opts select2's opts
+     * @return undefined/null to leave the current input unchanged, or a string to change the input to the returned value
+     */
+    function defaultTokenizer(input, selection, selectCallback, opts) {
+        var original = input, // store the original so we can compare and know if we need to tell the search to update its text
+            dupe = false, // check for whether a token we extracted represents a duplicate selected choice
+            token, // token
+            index, // position at which the separator was found
+            i, l, // looping variables
+            separator; // the matched separator
+
+        if (!opts.createSearchChoice || !opts.tokenSeparators || opts.tokenSeparators.length < 1) return undefined;
+
+        while (true) {
+            index = -1;
+
+            for (i = 0, l = opts.tokenSeparators.length; i < l; i++) {
+                separator = opts.tokenSeparators[i];
+                index = input.indexOf(separator);
+                if (index >= 0) break;
+            }
+
+            if (index < 0) break; // did not find any token separator in the input string, bail
+
+            token = input.substring(0, index);
+            input = input.substring(index + separator.length);
+
+            if (token.length > 0) {
+                token = opts.createSearchChoice(token, selection);
+                if (token !== undefined && token !== null && opts.id(token) !== undefined && opts.id(token) !== null) {
+                    dupe = false;
+                    for (i = 0, l = selection.length; i < l; i++) {
+                        if (equal(opts.id(token), opts.id(selection[i]))) {
+                            dupe = true; break;
+                        }
+                    }
+
+                    if (!dupe) selectCallback(token);
+                }
+            }
+        }
+
+        if (original!==input) return input;
+    }
+
+    /**
+     * Creates a new class
+     *
+     * @param superClass
+     * @param methods
+     */
+    function clazz(SuperClass, methods) {
+        var constructor = function () {};
+        constructor.prototype = new SuperClass;
+        constructor.prototype.constructor = constructor;
+        constructor.prototype.parent = SuperClass.prototype;
+        constructor.prototype = $.extend(constructor.prototype, methods);
+        return constructor;
+    }
+
+    AbstractSelect2 = clazz(Object, {
+
+        // abstract
+        bind: function (func) {
+            var self = this;
+            return function () {
+                func.apply(self, arguments);
+            };
+        },
+
+        // abstract
+        init: function (opts) {
+            var results, search, resultsSelector = ".select2-results", mask;
+
+            // prepare options
+            this.opts = opts = this.prepareOpts(opts);
+
+            this.id=opts.id;
+
+            // destroy if called on an existing component
+            if (opts.element.data("select2") !== undefined &&
+                opts.element.data("select2") !== null) {
+                this.destroy();
+            }
+
+            this.enabled=true;
+            this.container = this.createContainer();
+
+            this.containerId="s2id_"+(opts.element.attr("id") || "autogen"+nextUid());
+            this.containerSelector="#"+this.containerId.replace(/([;&,\.\+\*\~':"\!\^#$%@\[\]\(\)=>\|])/g, '\\$1');
+            this.container.attr("id", this.containerId);
+
+            // cache the body so future lookups are cheap
+            this.body = thunk(function() { return opts.element.closest("body"); });
+
+            syncCssClasses(this.container, this.opts.element, this.opts.adaptContainerCssClass);
+
+            this.container.css(evaluate(opts.containerCss));
+            this.container.addClass(evaluate(opts.containerCssClass));
+
+            this.elementTabIndex = this.opts.element.attr("tabIndex");
+
+            // swap container for the element
+            this.opts.element
+                .data("select2", this)
+                .addClass("select2-offscreen")
+                .bind("focus.select2", function() { $(this).select2("focus"); })
+                .attr("tabIndex", "-1")
+                .before(this.container);
+            this.container.data("select2", this);
+
+            this.dropdown = this.container.find(".select2-drop");
+            this.dropdown.addClass(evaluate(opts.dropdownCssClass));
+            this.dropdown.data("select2", this);
+
+            this.results = results = this.container.find(resultsSelector);
+            this.search = search = this.container.find("input.select2-input");
+
+            search.attr("tabIndex", this.elementTabIndex);
+
+            this.resultsPage = 0;
+            this.context = null;
+
+            // initialize the container
+            this.initContainer();
+
+            installFilteredMouseMove(this.results);
+            this.dropdown.delegate(resultsSelector, "mousemove-filtered touchstart touchmove touchend", this.bind(this.highlightUnderEvent));
+
+            installDebouncedScroll(80, this.results);
+            this.dropdown.delegate(resultsSelector, "scroll-debounced", this.bind(this.loadMoreIfNeeded));
+
+            // if jquery.mousewheel plugin is installed we can prevent out-of-bounds scrolling of results via mousewheel
+            if ($.fn.mousewheel) {
+                results.mousewheel(function (e, delta, deltaX, deltaY) {
+                    var top = results.scrollTop(), height;
+                    if (deltaY > 0 && top - deltaY <= 0) {
+                        results.scrollTop(0);
+                        killEvent(e);
+                    } else if (deltaY < 0 && results.get(0).scrollHeight - results.scrollTop() + deltaY <= results.height()) {
+                        results.scrollTop(results.get(0).scrollHeight - results.height());
+                        killEvent(e);
+                    }
+                });
+            }
+
+            installKeyUpChangeEvent(search);
+            search.bind("keyup-change input paste", this.bind(this.updateResults));
+            search.bind("focus", function () { search.addClass("select2-focused"); });
+            search.bind("blur", function () { search.removeClass("select2-focused");});
+
+            this.dropdown.delegate(resultsSelector, "mouseup", this.bind(function (e) {
+                if ($(e.target).closest(".select2-result-selectable").length > 0) {
+                    this.highlightUnderEvent(e);
+                    this.selectHighlighted(e);
+                }
+            }));
+
+            // trap all mouse events from leaving the dropdown. sometimes there may be a modal that is listening
+            // for mouse events outside of itself so it can close itself. since the dropdown is now outside the select2's
+            // dom it will trigger the popup close, which is not what we want
+            this.dropdown.bind("click mouseup mousedown", function (e) { e.stopPropagation(); });
+
+            if ($.isFunction(this.opts.initSelection)) {
+                // initialize selection based on the current value of the source element
+                this.initSelection();
+
+                // if the user has provided a function that can set selection based on the value of the source element
+                // we monitor the change event on the element and trigger it, allowing for two way synchronization
+                this.monitorSource();
+            }
+
+            if (opts.element.is(":disabled") || opts.element.is("[readonly='readonly']")) this.disable();
+        },
+
+        // abstract
+        destroy: function () {
+            var select2 = this.opts.element.data("select2");
+
+            if (this.propertyObserver) { delete this.propertyObserver; this.propertyObserver = null; }
+
+            if (select2 !== undefined) {
+
+                select2.container.remove();
+                select2.dropdown.remove();
+                select2.opts.element
+                    .removeClass("select2-offscreen")
+                    .removeData("select2")
+                    .unbind(".select2")
+                    .attr({"tabIndex": this.elementTabIndex})
+                    .show();
+            }
+        },
+
+        // abstract
+        prepareOpts: function (opts) {
+            var element, select, idKey, ajaxUrl;
+
+            element = opts.element;
+
+            if (element.get(0).tagName.toLowerCase() === "select") {
+                this.select = select = opts.element;
+            }
+
+            if (select) {
+                // these options are not allowed when attached to a select because they are picked up off the element itself
+                $.each(["id", "multiple", "ajax", "query", "createSearchChoice", "initSelection", "data", "tags"], function () {
+                    if (this in opts) {
+                        throw new Error("Option '" + this + "' is not allowed for Select2 when attached to a <select> element.");
+                    }
+                });
+            }
+
+            opts = $.extend({}, {
+                populateResults: function(container, results, query) {
+                    var populate,  data, result, children, id=this.opts.id, self=this;
+
+                    populate=function(results, container, depth) {
+
+                        var i, l, result, selectable, disabled, compound, node, label, innerContainer, formatted;
+
+                        results = opts.sortResults(results, container, query);
+
+                        for (i = 0, l = results.length; i < l; i = i + 1) {
+
+                            result=results[i];
+
+                            disabled = (result.disabled === true);
+                            selectable = (!disabled) && (id(result) !== undefined);
+
+                            compound=result.children && result.children.length > 0;
+
+                            node=$("<li></li>");
+                            node.addClass("select2-results-dept-"+depth);
+                            node.addClass("select2-result");
+                            node.addClass(selectable ? "select2-result-selectable" : "select2-result-unselectable");
+                            if (disabled) { node.addClass("select2-disabled"); }
+                            if (compound) { node.addClass("select2-result-with-children"); }
+                            node.addClass(self.opts.formatResultCssClass(result));
+
+                            label=$(document.createElement("div"));
+                            label.addClass("select2-result-label");
+
+                            formatted=opts.formatResult(result, label, query, self.opts.escapeMarkup);
+                            if (formatted!==undefined) {
+                                label.html(formatted);
+                            }
+
+                            node.append(label);
+
+                            if (compound) {
+
+                                innerContainer=$("<ul></ul>");
+                                innerContainer.addClass("select2-result-sub");
+                                populate(result.children, innerContainer, depth+1);
+                                node.append(innerContainer);
+                            }
+
+                            node.data("select2-data", result);
+                            container.append(node);
+                        }
+                    };
+
+                    populate(results, container, 0);
+                }
+            }, $.fn.select2.defaults, opts);
+
+            if (typeof(opts.id) !== "function") {
+                idKey = opts.id;
+                opts.id = function (e) { return e[idKey]; };
+            }
+
+            if ($.isArray(opts.element.data("select2Tags"))) {
+                if ("tags" in opts) {
+                    throw "tags specified as both an attribute 'data-select2-tags' and in options of Select2 " + opts.element.attr("id");
+                }
+                opts.tags=opts.element.attr("data-select2-tags");
+            }
+
+            if (select) {
+                opts.query = this.bind(function (query) {
+                    var data = { results: [], more: false },
+                        term = query.term,
+                        children, firstChild, process;
+
+                    process=function(element, collection) {
+                        var group;
+                        if (element.is("option")) {
+                            if (query.matcher(term, element.text(), element)) {
+                                collection.push({id:element.attr("value"), text:element.text(), element: element.get(), css: element.attr("class"), disabled: equal(element.attr("disabled"), "disabled") });
+                            }
+                        } else if (element.is("optgroup")) {
+                            group={text:element.attr("label"), children:[], element: element.get(), css: element.attr("class")};
+                            element.children().each2(function(i, elm) { process(elm, group.children); });
+                            if (group.children.length>0) {
+                                collection.push(group);
+                            }
+                        }
+                    };
+
+                    children=element.children();
+
+                    // ignore the placeholder option if there is one
+                    if (this.getPlaceholder() !== undefined && children.length > 0) {
+                        firstChild = children[0];
+                        if ($(firstChild).text() === "") {
+                            children=children.not(firstChild);
+                        }
+                    }
+
+                    children.each2(function(i, elm) { process(elm, data.results); });
+
+                    query.callback(data);
+                });
+                // this is needed because inside val() we construct choices from options and there id is hardcoded
+                opts.id=function(e) { return e.id; };
+                opts.formatResultCssClass = function(data) { return data.css; };
+            } else {
+                if (!("query" in opts)) {
+
+                    if ("ajax" in opts) {
+                        ajaxUrl = opts.element.data("ajax-url");
+                        if (ajaxUrl && ajaxUrl.length > 0) {
+                            opts.ajax.url = ajaxUrl;
+                        }
+                        opts.query = ajax.call(opts.element, opts.ajax);
+                    } else if ("data" in opts) {
+                        opts.query = local(opts.data);
+                    } else if ("tags" in opts) {
+                        opts.query = tags(opts.tags);
+                        if (opts.createSearchChoice === undefined) {
+                            opts.createSearchChoice = function (term) { return {id: term, text: term}; };
+                        }
+                        if (opts.initSelection === undefined) {
+                            opts.initSelection = function (element, callback) {
+                                var data = [];
+                                $(splitVal(element.val(), opts.separator)).each(function () {
+                                    var id = this, text = this, tags=opts.tags;
+                                    if ($.isFunction(tags)) tags=tags();
+                                    $(tags).each(function() { if (equal(this.id, id)) { text = this.text; return false; } });
+                                    data.push({id: id, text: text});
+                                });
+
+                                callback(data);
+                            };
+                        }
+                    }
+                }
+            }
+            if (typeof(opts.query) !== "function") {
+                throw "query function not defined for Select2 " + opts.element.attr("id");
+            }
+
+            return opts;
+        },
+
+        /**
+         * Monitor the original element for changes and update select2 accordingly
+         */
+        // abstract
+        monitorSource: function () {
+            var el = this.opts.element, sync;
+
+            el.bind("change.select2", this.bind(function (e) {
+                if (this.opts.element.data("select2-change-triggered") !== true) {
+                    this.initSelection();
+                }
+            }));
+
+            sync = this.bind(function () {
+
+                var enabled, readonly, self = this;
+
+                // sync enabled state
+
+                enabled = this.opts.element.attr("disabled") !== "disabled";
+                readonly = this.opts.element.attr("readonly") === "readonly";
+
+                enabled = enabled && !readonly;
+
+                if (this.enabled !== enabled) {
+                    if (enabled) {
+                        this.enable();
+                    } else {
+                        this.disable();
+                    }
+                }
+
+
+                syncCssClasses(this.container, this.opts.element, this.opts.adaptContainerCssClass);
+                this.container.addClass(evaluate(this.opts.containerCssClass));
+
+                syncCssClasses(this.dropdown, this.opts.element, this.opts.adaptDropdownCssClass);
+                this.dropdown.addClass(evaluate(this.opts.dropdownCssClass));
+
+            });
+
+            // mozilla and IE
+            el.bind("propertychange.select2 DOMAttrModified.select2", sync);
+            // safari and chrome
+            if (typeof WebKitMutationObserver !== "undefined") {
+                if (this.propertyObserver) { delete this.propertyObserver; this.propertyObserver = null; }
+                this.propertyObserver = new WebKitMutationObserver(function (mutations) {
+                    mutations.forEach(sync);
+                });
+                this.propertyObserver.observe(el.get(0), { attributes:true, subtree:false });
+            }
+        },
+
+        /**
+         * Triggers the change event on the source element
+         */
+        // abstract
+        triggerChange: function (details) {
+
+            details = details || {};
+            details= $.extend({}, details, { type: "change", val: this.val() });
+            // prevents recursive triggering
+            this.opts.element.data("select2-change-triggered", true);
+            this.opts.element.trigger(details);
+            this.opts.element.data("select2-change-triggered", false);
+
+            // some validation frameworks ignore the change event and listen instead to keyup, click for selects
+            // so here we trigger the click event manually
+            this.opts.element.click();
+
+            // ValidationEngine ignorea the change event and listens instead to blur
+            // so here we trigger the blur event manually if so desired
+            if (this.opts.blurOnChange)
+                this.opts.element.blur();
+        },
+
+        // abstract
+        enable: function() {
+            if (this.enabled) return;
+
+            this.enabled=true;
+            this.container.removeClass("select2-container-disabled");
+            this.opts.element.removeAttr("disabled");
+        },
+
+        // abstract
+        disable: function() {
+            if (!this.enabled) return;
+
+            this.close();
+
+            this.enabled=false;
+            this.container.addClass("select2-container-disabled");
+            this.opts.element.attr("disabled", "disabled");
+        },
+
+        // abstract
+        opened: function () {
+            return this.container.hasClass("select2-dropdown-open");
+        },
+
+        // abstract
+        positionDropdown: function() {
+            var offset = this.container.offset(),
+                height = this.container.outerHeight(false),
+                width = this.container.outerWidth(false),
+                dropHeight = this.dropdown.outerHeight(false),
+	            viewPortRight = $(window).scrollLeft() + $(window).width(),
+                viewportBottom = $(window).scrollTop() + $(window).height(),
+                dropTop = offset.top + height,
+                dropLeft = offset.left,
+                enoughRoomBelow = dropTop + dropHeight <= viewportBottom,
+                enoughRoomAbove = (offset.top - dropHeight) >= this.body().scrollTop(),
+	            dropWidth = this.dropdown.outerWidth(false),
+	            enoughRoomOnRight = dropLeft + dropWidth <= viewPortRight,
+                aboveNow = this.dropdown.hasClass("select2-drop-above"),
+                bodyOffset,
+                above,
+                css;
+
+            //console.log("below/ droptop:", dropTop, "dropHeight", dropHeight, "sum", (dropTop+dropHeight)+" viewport bottom", viewportBottom, "enough?", enoughRoomBelow);
+            //console.log("above/ offset.top", offset.top, "dropHeight", dropHeight, "top", (offset.top-dropHeight), "scrollTop", this.body().scrollTop(), "enough?", enoughRoomAbove);
+
+            // fix positioning when body has an offset and is not position: static
+
+            if (this.body().css('position') !== 'static') {
+                bodyOffset = this.body().offset();
+                dropTop -= bodyOffset.top;
+                dropLeft -= bodyOffset.left;
+            }
+
+            // always prefer the current above/below alignment, unless there is not enough room
+
+            if (aboveNow) {
+                above = true;
+                if (!enoughRoomAbove && enoughRoomBelow) above = false;
+            } else {
+                above = false;
+                if (!enoughRoomBelow && enoughRoomAbove) above = true;
+            }
+
+            if (!enoughRoomOnRight) {
+               dropLeft = offset.left + width - dropWidth;
+            }
+
+            if (above) {
+                dropTop = offset.top - dropHeight;
+                this.container.addClass("select2-drop-above");
+                this.dropdown.addClass("select2-drop-above");
+            }
+            else {
+                this.container.removeClass("select2-drop-above");
+                this.dropdown.removeClass("select2-drop-above");
+            }
+
+            css = $.extend({
+                top: dropTop,
+                left: dropLeft,
+                width: width
+            }, evaluate(this.opts.dropdownCss));
+
+            this.dropdown.css(css);
+        },
+
+        // abstract
+        shouldOpen: function() {
+            var event;
+
+            if (this.opened()) return false;
+
+            event = $.Event("opening");
+            this.opts.element.trigger(event);
+            return !event.isDefaultPrevented();
+        },
+
+        // abstract
+        clearDropdownAlignmentPreference: function() {
+            // clear the classes used to figure out the preference of where the dropdown should be opened
+            this.container.removeClass("select2-drop-above");
+            this.dropdown.removeClass("select2-drop-above");
+        },
+
+        /**
+         * Opens the dropdown
+         *
+         * @return {Boolean} whether or not dropdown was opened. This method will return false if, for example,
+         * the dropdown is already open, or if the 'open' event listener on the element called preventDefault().
+         */
+        // abstract
+        open: function () {
+
+            if (!this.shouldOpen()) return false;
+
+            window.setTimeout(this.bind(this.opening), 1);
+
+            return true;
+        },
+
+        /**
+         * Performs the opening of the dropdown
+         */
+        // abstract
+        opening: function() {
+            var cid = this.containerId,
+                scroll = "scroll." + cid,
+                resize = "resize."+cid,
+                orient = "orientationchange."+cid,
+                mask;
+
+            this.clearDropdownAlignmentPreference();
+
+            this.container.addClass("select2-dropdown-open").addClass("select2-container-active");
+
+
+            if(this.dropdown[0] !== this.body().children().last()[0]) {
+                this.dropdown.detach().appendTo(this.body());
+            }
+
+            this.updateResults(true);
+
+            // create the dropdown mask if doesnt already exist
+            mask = $("#select2-drop-mask");
+            if (mask.length == 0) {
+                mask = $(document.createElement("div"));
+                mask.attr("id","select2-drop-mask").attr("class","select2-drop-mask");
+                mask.hide();
+                mask.appendTo(this.body());
+                mask.bind("mousedown touchstart", function (e) {
+                    var dropdown = $("#select2-drop"), self;
+                    if (dropdown.length > 0) {
+                        self=dropdown.data("select2");
+                        if (self.opts.selectOnBlur) {
+                            self.selectHighlighted({noFocus: true});
+                        }
+                        self.close();
+                    }
+                });
+            }
+
+            // ensure the mask is always right before the dropdown
+            if (this.dropdown.prev()[0] !== mask[0]) {
+                this.dropdown.before(mask);
+            }
+
+            // move the global id to the correct dropdown
+            $("#select2-drop").removeAttr("id");
+            this.dropdown.attr("id", "select2-drop");
+
+            // show the elements
+            mask.css({
+                width: document.documentElement.scrollWidth,
+                height: document.documentElement.scrollHeight});
+            mask.show();
+            this.dropdown.show();
+            this.positionDropdown();
+
+            this.dropdown.addClass("select2-drop-active");
+            this.ensureHighlightVisible();
+
+            // attach listeners to events that can change the position of the container and thus require
+            // the position of the dropdown to be updated as well so it does not come unglued from the container
+            var that = this;
+            this.container.parents().add(window).each(function () {
+                $(this).bind(resize+" "+scroll+" "+orient, function (e) {
+                    $("#select2-drop-mask").css({
+                        width:document.documentElement.scrollWidth,
+                        height:document.documentElement.scrollHeight});
+                    that.positionDropdown();
+                });
+            });
+
+            this.focusSearch();
+        },
+
+        // abstract
+        close: function () {
+            if (!this.opened()) return;
+
+            var cid = this.containerId,
+                scroll = "scroll." + cid,
+                resize = "resize."+cid,
+                orient = "orientationchange."+cid;
+
+            // unbind event listeners
+            this.container.parents().add(window).each(function () { $(this).unbind(scroll).unbind(resize).unbind(orient); });
+
+            this.clearDropdownAlignmentPreference();
+
+            $("#select2-drop-mask").hide();
+            this.dropdown.removeAttr("id"); // only the active dropdown has the select2-drop id
+            this.dropdown.hide();
+            this.container.removeClass("select2-dropdown-open");
+            this.results.empty();
+            this.clearSearch();
+
+            this.opts.element.trigger($.Event("close"));
+        },
+
+        // abstract
+        clearSearch: function () {
+
+        },
+
+        //abstract
+        getMaximumSelectionSize: function() {
+            return evaluate(this.opts.maximumSelectionSize);
+        },
+
+        // abstract
+        ensureHighlightVisible: function () {
+            var results = this.results, children, index, child, hb, rb, y, more;
+
+            index = this.highlight();
+
+            if (index < 0) return;
+
+            if (index == 0) {
+
+                // if the first element is highlighted scroll all the way to the top,
+                // that way any unselectable headers above it will also be scrolled
+                // into view
+
+                results.scrollTop(0);
+                return;
+            }
+
+            children = this.findHighlightableChoices();
+
+            child = $(children[index]);
+
+            hb = child.offset().top + child.outerHeight(true);
+
+            // if this is the last child lets also make sure select2-more-results is visible
+            if (index === children.length - 1) {
+                more = results.find("li.select2-more-results");
+                if (more.length > 0) {
+                    hb = more.offset().top + more.outerHeight(true);
+                }
+            }
+
+            rb = results.offset().top + results.outerHeight(true);
+            if (hb > rb) {
+                results.scrollTop(results.scrollTop() + (hb - rb));
+            }
+            y = child.offset().top - results.offset().top;
+
+            // make sure the top of the element is visible
+            if (y < 0 && child.css('display') != 'none' ) {
+                results.scrollTop(results.scrollTop() + y); // y is negative
+            }
+        },
+
+        // abstract
+        findHighlightableChoices: function() {
+            var h=this.results.find(".select2-result-selectable:not(.select2-selected):not(.select2-disabled)");
+            return this.results.find(".select2-result-selectable:not(.select2-selected):not(.select2-disabled)");
+        },
+
+        // abstract
+        moveHighlight: function (delta) {
+            var choices = this.findHighlightableChoices(),
+                index = this.highlight();
+
+            while (index > -1 && index < choices.length) {
+                index += delta;
+                var choice = $(choices[index]);
+                if (choice.hasClass("select2-result-selectable") && !choice.hasClass("select2-disabled") && !choice.hasClass("select2-selected")) {
+                    this.highlight(index);
+                    break;
+                }
+            }
+        },
+
+        // abstract
+        highlight: function (index) {
+            var choices = this.findHighlightableChoices(),
+                choice,
+                data;
+
+            if (arguments.length === 0) {
+                return indexOf(choices.filter(".select2-highlighted")[0], choices.get());
+            }
+
+            if (index >= choices.length) index = choices.length - 1;
+            if (index < 0) index = 0;
+
+            this.results.find(".select2-highlighted").removeClass("select2-highlighted");
+
+            choice = $(choices[index]);
+            choice.addClass("select2-highlighted");
+
+            this.ensureHighlightVisible();
+
+            data = choice.data("select2-data");
+            if (data) {
+                this.opts.element.trigger({ type: "highlight", val: this.id(data), choice: data });
+            }
+        },
+
+        // abstract
+        countSelectableResults: function() {
+            return this.findHighlightableChoices().length;
+        },
+
+        // abstract
+        highlightUnderEvent: function (event) {
+            var el = $(event.target).closest(".select2-result-selectable");
+            if (el.length > 0 && !el.is(".select2-highlighted")) {
+        		var choices = this.findHighlightableChoices();
+                this.highlight(choices.index(el));
+            } else if (el.length == 0) {
+                // if we are over an unselectable item remove al highlights
+                this.results.find(".select2-highlighted").removeClass("select2-highlighted");
+            }
+        },
+
+        // abstract
+        loadMoreIfNeeded: function () {
+            var results = this.results,
+                more = results.find("li.select2-more-results"),
+                below, // pixels the element is below the scroll fold, below==0 is when the element is starting to be visible
+                offset = -1, // index of first element without data
+                page = this.resultsPage + 1,
+                self=this,
+                term=this.search.val(),
+                context=this.context;
+
+            if (more.length === 0) return;
+            below = more.offset().top - results.offset().top - results.height();
+
+            if (below <= this.opts.loadMorePadding) {
+                more.addClass("select2-active");
+                this.opts.query({
+                        element: this.opts.element,
+                        term: term,
+                        page: page,
+                        context: context,
+                        matcher: this.opts.matcher,
+                        callback: this.bind(function (data) {
+
+                    // ignore a response if the select2 has been closed before it was received
+                    if (!self.opened()) return;
+
+
+                    self.opts.populateResults.call(this, results, data.results, {term: term, page: page, context:context});
+
+                    if (data.more===true) {
+                        more.detach().appendTo(results).text(self.opts.formatLoadMore(page+1));
+                        window.setTimeout(function() { self.loadMoreIfNeeded(); }, 10);
+                    } else {
+                        more.remove();
+                    }
+                    self.positionDropdown();
+                    self.resultsPage = page;
+                    self.context = data.context;
+                })});
+            }
+        },
+
+        /**
+         * Default tokenizer function which does nothing
+         */
+        tokenize: function() {
+
+        },
+
+        /**
+         * @param initial whether or not this is the call to this method right after the dropdown has been opened
+         */
+        // abstract
+        updateResults: function (initial) {
+            var search = this.search, results = this.results, opts = this.opts, data, self=this, input;
+
+            // if the search is currently hidden we do not alter the results
+            if (initial !== true && (this.showSearchInput === false || !this.opened())) {
+                return;
+            }
+
+            search.addClass("select2-active");
+
+            function postRender() {
+                results.scrollTop(0);
+                search.removeClass("select2-active");
+                self.positionDropdown();
+            }
+
+            function render(html) {
+                results.html(html);
+                postRender();
+            }
+
+            var maxSelSize = this.getMaximumSelectionSize();
+            if (maxSelSize >=1) {
+                data = this.data();
+                if ($.isArray(data) && data.length >= maxSelSize && checkFormatter(opts.formatSelectionTooBig, "formatSelectionTooBig")) {
+            	    render("<li class='select2-selection-limit'>" + opts.formatSelectionTooBig(maxSelSize) + "</li>");
+            	    return;
+                }
+            }
+
+            if (search.val().length < opts.minimumInputLength) {
+                if (checkFormatter(opts.formatInputTooShort, "formatInputTooShort")) {
+                    render("<li class='select2-no-results'>" + opts.formatInputTooShort(search.val(), opts.minimumInputLength) + "</li>");
+                } else {
+                    render("");
+                }
+                return;
+            }
+            else if (opts.formatSearching() && initial===true) {
+                render("<li class='select2-searching'>" + opts.formatSearching() + "</li>");
+            }
+
+            if (opts.maximumInputLength && search.val().length > opts.maximumInputLength) {
+                if (checkFormatter(opts.formatInputTooLong, "formatInputTooLong")) {
+                    render("<li class='select2-no-results'>" + opts.formatInputTooLong(search.val(), opts.maximumInputLength) + "</li>");
+                } else {
+                    render("");
+                }
+                return;
+            }
+
+            // give the tokenizer a chance to pre-process the input
+            input = this.tokenize();
+            if (input != undefined && input != null) {
+                search.val(input);
+            }
+
+            this.resultsPage = 1;
+
+            opts.query({
+                element: opts.element,
+                    term: search.val(),
+                    page: this.resultsPage,
+                    context: null,
+                    matcher: opts.matcher,
+                    callback: this.bind(function (data) {
+                var def; // default choice
+
+                // ignore a response if the select2 has been closed before it was received
+                if (!this.opened()) return;
+
+                // save context, if any
+                this.context = (data.context===undefined) ? null : data.context;
+                // create a default choice and prepend it to the list
+                if (this.opts.createSearchChoice && search.val() !== "") {
+                    def = this.opts.createSearchChoice.call(null, search.val(), data.results);
+                    if (def !== undefined && def !== null && self.id(def) !== undefined && self.id(def) !== null) {
+                        if ($(data.results).filter(
+                            function () {
+                                return equal(self.id(this), self.id(def));
+                            }).length === 0) {
+                            data.results.unshift(def);
+                        }
+                    }
+                }
+
+                if (data.results.length === 0 && checkFormatter(opts.formatNoMatches, "formatNoMatches")) {
+                    render("<li class='select2-no-results'>" + opts.formatNoMatches(search.val()) + "</li>");
+                    return;
+                }
+
+                results.empty();
+                self.opts.populateResults.call(this, results, data.results, {term: search.val(), page: this.resultsPage, context:null});
+
+                if (data.more === true && checkFormatter(opts.formatLoadMore, "formatLoadMore")) {
+                    results.append("<li class='select2-more-results'>" + self.opts.escapeMarkup(opts.formatLoadMore(this.resultsPage)) + "</li>");
+                    window.setTimeout(function() { self.loadMoreIfNeeded(); }, 10);
+                }
+
+                this.postprocessResults(data, initial);
+
+                postRender();
+            })});
+        },
+
+        // abstract
+        cancel: function () {
+            this.close();
+        },
+
+        // abstract
+        blur: function () {
+            // if selectOnBlur == true, select the currently highlighted option
+            if (this.opts.selectOnBlur)
+                this.selectHighlighted({noFocus: true});
+
+            this.close();
+            this.container.removeClass("select2-container-active");
+            // synonymous to .is(':focus'), which is available in jquery >= 1.6
+            if (this.search[0] === document.activeElement) { this.search.blur(); }
+            this.clearSearch();
+            this.selection.find(".select2-search-choice-focus").removeClass("select2-search-choice-focus");
+        },
+
+        // abstract
+        focusSearch: function () {
+            focus(this.search);
+        },
+
+        // abstract
+        selectHighlighted: function (options) {
+            var index=this.highlight(),
+                highlighted=this.results.find(".select2-highlighted"),
+                data = highlighted.closest('.select2-result').data("select2-data");
+
+            if (data) {
+                this.highlight(index);
+                this.onSelect(data, options);
+            }
+        },
+
+        // abstract
+        getPlaceholder: function () {
+            return this.opts.element.attr("placeholder") ||
+                this.opts.element.attr("data-placeholder") || // jquery 1.4 compat
+                this.opts.element.data("placeholder") ||
+                this.opts.placeholder;
+        },
+
+        /**
+         * Get the desired width for the container element.  This is
+         * derived first from option `width` passed to select2, then
+         * the inline 'style' on the original element, and finally
+         * falls back to the jQuery calculated element width.
+         */
+        // abstract
+        initContainerWidth: function () {
+            function resolveContainerWidth() {
+                var style, attrs, matches, i, l;
+
+                if (this.opts.width === "off") {
+                    return null;
+                } else if (this.opts.width === "element"){
+                    return this.opts.element.outerWidth(false) === 0 ? 'auto' : this.opts.element.outerWidth(false) + 'px';
+                } else if (this.opts.width === "copy" || this.opts.width === "resolve") {
+                    // check if there is inline style on the element that contains width
+                    style = this.opts.element.attr('style');
+                    if (style !== undefined) {
+                        attrs = style.split(';');
+                        for (i = 0, l = attrs.length; i < l; i = i + 1) {
+                            matches = attrs[i].replace(/\s/g, '')
+                                .match(/width:(([-+]?([0-9]*\.)?[0-9]+)(px|em|ex|%|in|cm|mm|pt|pc))/);
+                            if (matches !== null && matches.length >= 1)
+                                return matches[1];
+                        }
+                    }
+
+                    if (this.opts.width === "resolve") {
+                        // next check if css('width') can resolve a width that is percent based, this is sometimes possible
+                        // when attached to input type=hidden or elements hidden via css
+                        style = this.opts.element.css('width');
+                        if (style.indexOf("%") > 0) return style;
+
+                        // finally, fallback on the calculated width of the element
+                        return (this.opts.element.outerWidth(false) === 0 ? 'auto' : this.opts.element.outerWidth(false) + 'px');
+                    }
+
+                    return null;
+                } else if ($.isFunction(this.opts.width)) {
+                    return this.opts.width();
+                } else {
+                    return this.opts.width;
+               }
+            };
+
+            var width = resolveContainerWidth.call(this);
+            if (width !== null) {
+                this.container.css("width", width);
+            }
+        }
+    });
+
+    SingleSelect2 = clazz(AbstractSelect2, {
+
+        // single
+
+		createContainer: function () {
+            var container = $(document.createElement("div")).attr({
+                "class": "select2-container"
+            }).html([
+                "<a href='javascript:void(0)' onclick='return false;' class='select2-choice' tabindex='-1'>",
+                "   <span></span><abbr class='select2-search-choice-close' style='display:none;'></abbr>",
+                "   <div><b></b></div>" ,
+                "</a>",
+                "<input class='select2-focusser select2-offscreen' type='text'/>",
+                "<div class='select2-drop' style='display:none'>" ,
+                "   <div class='select2-search'>" ,
+                "       <input type='text' autocomplete='off' class='select2-input'/>" ,
+                "   </div>" ,
+                "   <ul class='select2-results'>" ,
+                "   </ul>" ,
+                "</div>"].join(""));
+            return container;
+        },
+
+        // single
+        disable: function() {
+            if (!this.enabled) return;
+
+            this.parent.disable.apply(this, arguments);
+
+            this.focusser.attr("disabled", "disabled");
+        },
+
+        // single
+        enable: function() {
+            if (this.enabled) return;
+
+            this.parent.enable.apply(this, arguments);
+
+            this.focusser.removeAttr("disabled");
+        },
+
+        // single
+        opening: function () {
+            this.parent.opening.apply(this, arguments);
+            this.focusser.attr("disabled", "disabled");
+
+            this.opts.element.trigger($.Event("open"));
+        },
+
+        // single
+        close: function () {
+            if (!this.opened()) return;
+            this.parent.close.apply(this, arguments);
+            this.focusser.removeAttr("disabled");
+            focus(this.focusser);
+        },
+
+        // single
+        focus: function () {
+            if (this.opened()) {
+                this.close();
+            } else {
+                this.focusser.removeAttr("disabled");
+                this.focusser.focus();
+            }
+        },
+
+        // single
+        isFocused: function () {
+            return this.container.hasClass("select2-container-active");
+        },
+
+        // single
+        cancel: function () {
+            this.parent.cancel.apply(this, arguments);
+            this.focusser.removeAttr("disabled");
+            this.focusser.focus();
+        },
+
+        // single
+        initContainer: function () {
+
+            var selection,
+                container = this.container,
+                dropdown = this.dropdown,
+                clickingInside = false;
+
+            this.showSearch(this.opts.minimumResultsForSearch >= 0);
+
+            this.selection = selection = container.find(".select2-choice");
+
+            this.focusser = container.find(".select2-focusser");
+
+            this.search.bind("keydown", this.bind(function (e) {
+                if (!this.enabled) return;
+
+                if (e.which === KEY.PAGE_UP || e.which === KEY.PAGE_DOWN) {
+                    // prevent the page from scrolling
+                    killEvent(e);
+                    return;
+                }
+
+                switch (e.which) {
+                    case KEY.UP:
+                    case KEY.DOWN:
+                        this.moveHighlight((e.which === KEY.UP) ? -1 : 1);
+                        killEvent(e);
+                        return;
+                    case KEY.TAB:
+                    case KEY.ENTER:
+                        this.selectHighlighted();
+                        killEvent(e);
+                        return;
+                    case KEY.ESC:
+                        this.cancel(e);
+                        killEvent(e);
+                        return;
+                }
+            }));
+
+            this.focusser.bind("keydown", this.bind(function (e) {
+                if (!this.enabled) return;
+
+                if (e.which === KEY.TAB || KEY.isControl(e) || KEY.isFunctionKey(e) || e.which === KEY.ESC) {
+                    return;
+                }
+
+                if (this.opts.openOnEnter === false && e.which === KEY.ENTER) {
+                    killEvent(e);
+                    return;
+                }
+
+                if (e.which == KEY.DOWN || e.which == KEY.UP
+                    || (e.which == KEY.ENTER && this.opts.openOnEnter)) {
+                    this.open();
+                    killEvent(e);
+                    return;
+                }
+
+                if (e.which == KEY.DELETE || e.which == KEY.BACKSPACE) {
+                    if (this.opts.allowClear) {
+                        this.clear();
+                    }
+                    killEvent(e);
+                    return;
+                }
+            }));
+
+
+            installKeyUpChangeEvent(this.focusser);
+            this.focusser.bind("keyup-change input", this.bind(function(e) {
+                if (this.opened()) return;
+                this.open();
+                if (this.showSearchInput !== false) {
+                    this.search.val(this.focusser.val());
+                }
+                this.focusser.val("");
+                killEvent(e);
+            }));
+
+            selection.delegate("abbr", "mousedown", this.bind(function (e) {
+                if (!this.enabled) return;
+                this.clear();
+                killEventImmediately(e);
+                this.close();
+                this.selection.focus();
+            }));
+
+            selection.bind("mousedown", this.bind(function (e) {
+                clickingInside = true;
+
+                if (this.opened()) {
+                    this.close();
+                } else if (this.enabled) {
+                    this.open();
+                }
+
+                killEvent(e);
+
+                clickingInside = false;
+            }));
+
+            dropdown.bind("mousedown", this.bind(function() { this.search.focus(); }));
+
+            selection.bind("focus", this.bind(function(e) {
+                killEvent(e);
+            }));
+
+            this.focusser.bind("focus", this.bind(function(){
+                this.container.addClass("select2-container-active");
+            })).bind("blur", this.bind(function() {
+                if (!this.opened()) {
+                    this.container.removeClass("select2-container-active");
+                }
+            }));
+            this.search.bind("focus", this.bind(function(){
+                this.container.addClass("select2-container-active");
+            }))
+
+            this.initContainerWidth();
+            this.setPlaceholder();
+
+        },
+
+        // single
+        clear: function() {
+            var data=this.selection.data("select2-data");
+            this.opts.element.val("");
+            this.selection.find("span").empty();
+            this.selection.removeData("select2-data");
+            this.setPlaceholder();
+
+            this.opts.element.trigger({ type: "removed", val: this.id(data), choice: data });
+            this.triggerChange({removed:data});
+        },
+
+        /**
+         * Sets selection based on source element's value
+         */
+        // single
+        initSelection: function () {
+            var selected;
+            if (this.opts.element.val() === "" && this.opts.element.text() === "") {
+                this.close();
+                this.setPlaceholder();
+            } else {
+                var self = this;
+                this.opts.initSelection.call(null, this.opts.element, function(selected){
+                    if (selected !== undefined && selected !== null) {
+                        self.updateSelection(selected);
+                        self.close();
+                        self.setPlaceholder();
+                    }
+                });
+            }
+        },
+
+        // single
+        prepareOpts: function () {
+            var opts = this.parent.prepareOpts.apply(this, arguments);
+
+            if (opts.element.get(0).tagName.toLowerCase() === "select") {
+                // install the selection initializer
+                opts.initSelection = function (element, callback) {
+                    var selected = element.find(":selected");
+                    // a single select box always has a value, no need to null check 'selected'
+                    if ($.isFunction(callback))
+                        callback({id: selected.attr("value"), text: selected.text(), element:selected});
+                };
+            } else if ("data" in opts) {
+                // install default initSelection when applied to hidden input and data is local
+                opts.initSelection = opts.initSelection || function (element, callback) {
+                    var id = element.val();
+                    //search in data by id
+                    opts.query({
+                        matcher: function(term, text, el){
+                            return equal(id, opts.id(el));
+                        },
+                        callback: !$.isFunction(callback) ? $.noop : function(filtered) {
+                            callback(filtered.results.length ? filtered.results[0] : null);
+                        }
+                    });
+                };
+            }
+
+            return opts;
+        },
+
+        // single
+        getPlaceholder: function() {
+            // if a placeholder is specified on a single select without the first empty option ignore it
+            if (this.select) {
+                if (this.select.find("option").first().text() !== "") {
+                    return undefined;
+                }
+            }
+
+            return this.parent.getPlaceholder.apply(this, arguments);
+        },
+
+        // single
+        setPlaceholder: function () {
+            var placeholder = this.getPlaceholder();
+
+            if (this.opts.element.val() === "" && placeholder !== undefined) {
+
+                // check for a first blank option if attached to a select
+                if (this.select && this.select.find("option:first").text() !== "") return;
+
+                this.selection.find("span").html(this.opts.escapeMarkup(placeholder));
+
+                this.selection.addClass("select2-default");
+
+                this.selection.find("abbr").hide();
+            }
+        },
+
+        // single
+        postprocessResults: function (data, initial) {
+            var selected = 0, self = this, showSearchInput = true;
+
+            // find the selected element in the result list
+
+            this.findHighlightableChoices().each2(function (i, elm) {
+                if (equal(self.id(elm.data("select2-data")), self.opts.element.val())) {
+                    selected = i;
+                    return false;
+                }
+            });
+
+            // and highlight it
+
+            this.highlight(selected);
+
+            // hide the search box if this is the first we got the results and there are a few of them
+
+            if (initial === true) {
+                var min=this.opts.minimumResultsForSearch;
+                showSearchInput  = min < 0 ? false : countResults(data.results) >= min;
+                this.showSearch(showSearchInput);
+            }
+
+        },
+
+        // single
+        showSearch: function(showSearchInput) {
+            this.showSearchInput = showSearchInput;
+
+            this.dropdown.find(".select2-search")[showSearchInput ? "removeClass" : "addClass"]("select2-search-hidden");
+            //add "select2-with-searchbox" to the container if search box is shown
+            $(this.dropdown, this.container)[showSearchInput ? "addClass" : "removeClass"]("select2-with-searchbox");
+        },
+
+        // single
+        onSelect: function (data, options) {
+            var old = this.opts.element.val();
+
+            this.opts.element.val(this.id(data));
+            this.updateSelection(data);
+
+            this.opts.element.trigger({ type: "selected", val: this.id(data), choice: data });
+
+            this.close();
+
+            if (!options || !options.noFocus)
+                this.selection.focus();
+
+            if (!equal(old, this.id(data))) { this.triggerChange(); }
+        },
+
+        // single
+        updateSelection: function (data) {
+
+            var container=this.selection.find("span"), formatted;
+
+            this.selection.data("select2-data", data);
+
+            container.empty();
+            formatted=this.opts.formatSelection(data, container);
+            if (formatted !== undefined) {
+                container.append(this.opts.escapeMarkup(formatted));
+            }
+
+            this.selection.removeClass("select2-default");
+
+            if (this.opts.allowClear && this.getPlaceholder() !== undefined) {
+                this.selection.find("abbr").show();
+            }
+        },
+
+        // single
+        val: function () {
+            var val, triggerChange = false, data = null, self = this;
+
+            if (arguments.length === 0) {
+                return this.opts.element.val();
+            }
+
+            val = arguments[0];
+
+            if (arguments.length > 1) {
+                triggerChange = arguments[1];
+            }
+
+            if (this.select) {
+                this.select
+                    .val(val)
+                    .find(":selected").each2(function (i, elm) {
+                        data = {id: elm.attr("value"), text: elm.text()};
+                        return false;
+                    });
+                this.updateSelection(data);
+                this.setPlaceholder();
+                if (triggerChange) {
+                    this.triggerChange();
+                }
+            } else {
+                if (this.opts.initSelection === undefined) {
+                    throw new Error("cannot call val() if initSelection() is not defined");
+                }
+                // val is an id. !val is true for [undefined,null,'',0] - 0 is legal
+                if (!val && val !== 0) {
+                    this.clear();
+                    if (triggerChange) {
+                        this.triggerChange();
+                    }
+                    return;
+                }
+                this.opts.element.val(val);
+                this.opts.initSelection(this.opts.element, function(data){
+                    self.opts.element.val(!data ? "" : self.id(data));
+                    self.updateSelection(data);
+                    self.setPlaceholder();
+                    if (triggerChange) {
+                        self.triggerChange();
+                    }
+                });
+            }
+        },
+
+        // single
+        clearSearch: function () {
+            this.search.val("");
+            this.focusser.val("");
+        },
+
+        // single
+        data: function(value) {
+            var data;
+
+            if (arguments.length === 0) {
+                data = this.selection.data("select2-data");
+                if (data == undefined) data = null;
+                return data;
+            } else {
+                if (!value || value === "") {
+                    this.clear();
+                } else {
+                    this.opts.element.val(!value ? "" : this.id(value));
+                    this.updateSelection(value);
+                }
+            }
+        }
+    });
+
+    MultiSelect2 = clazz(AbstractSelect2, {
+
+        // multi
+        createContainer: function () {
+            var container = $(document.createElement("div")).attr({
+                "class": "select2-container select2-container-multi"
+            }).html([
+                "    <ul class='select2-choices'>",
+                //"<li class='select2-search-choice'><span>California</span><a href="javascript:void(0)" class="select2-search-choice-close"></a></li>" ,
+                "  <li class='select2-search-field'>" ,
+                "    <input type='text' autocomplete='off' class='select2-input'>" ,
+                "  </li>" ,
+                "</ul>" ,
+                "<div class='select2-drop select2-drop-multi' style='display:none;'>" ,
+                "   <ul class='select2-results'>" ,
+                "   </ul>" ,
+                "</div>"].join(""));
+			return container;
+        },
+
+        // multi
+        prepareOpts: function () {
+            var opts = this.parent.prepareOpts.apply(this, arguments);
+
+            // TODO validate placeholder is a string if specified
+
+            if (opts.element.get(0).tagName.toLowerCase() === "select") {
+                // install sthe selection initializer
+                opts.initSelection = function (element, callback) {
+
+                    var data = [];
+
+                    element.find(":selected").each2(function (i, elm) {
+                        data.push({id: elm.attr("value"), text: elm.text(), element: elm[0]});
+                    });
+                    callback(data);
+                };
+            } else if ("data" in opts) {
+                // install default initSelection when applied to hidden input and data is local
+                opts.initSelection = opts.initSelection || function (element, callback) {
+                    var ids = splitVal(element.val(), opts.separator);
+                    //search in data by array of ids
+                    opts.query({
+                        matcher: function(term, text, el){
+                            return $.grep(ids, function(id) {
+                                return equal(id, opts.id(el));
+                            }).length;
+                        },
+                        callback: !$.isFunction(callback) ? $.noop : function(filtered) {
+                            callback(filtered.results);
+                        }
+                    });
+                };
+            }
+
+            return opts;
+        },
+
+        // multi
+        initContainer: function () {
+
+            var selector = ".select2-choices", selection;
+
+            this.searchContainer = this.container.find(".select2-search-field");
+            this.selection = selection = this.container.find(selector);
+
+            this.search.bind("input paste", this.bind(function() {
+                if (!this.enabled) return;
+                if (!this.opened()) {
+                    this.open();
+                }
+            }));
+
+            this.search.bind("keydown", this.bind(function (e) {
+                if (!this.enabled) return;
+
+                if (e.which === KEY.BACKSPACE && this.search.val() === "") {
+                    this.close();
+
+                    var choices,
+                        selected = selection.find(".select2-search-choice-focus");
+                    if (selected.length > 0) {
+                        this.unselect(selected.first());
+                        this.search.width(10);
+                        killEvent(e);
+                        return;
+                    }
+
+                    choices = selection.find(".select2-search-choice:not(.select2-locked)");
+                    if (choices.length > 0) {
+                        choices.last().addClass("select2-search-choice-focus");
+                    }
+                } else {
+                    selection.find(".select2-search-choice-focus").removeClass("select2-search-choice-focus");
+                }
+
+                if (this.opened()) {
+                    switch (e.which) {
+                    case KEY.UP:
+                    case KEY.DOWN:
+                        this.moveHighlight((e.which === KEY.UP) ? -1 : 1);
+                        killEvent(e);
+                        return;
+                    case KEY.ENTER:
+                    case KEY.TAB:
+                        this.selectHighlighted();
+                        killEvent(e);
+                        return;
+                    case KEY.ESC:
+                        this.cancel(e);
+                        killEvent(e);
+                        return;
+                    }
+                }
+
+                if (e.which === KEY.TAB || KEY.isControl(e) || KEY.isFunctionKey(e)
+                 || e.which === KEY.BACKSPACE || e.which === KEY.ESC) {
+                    return;
+                }
+
+                if (e.which === KEY.ENTER) {
+                    if (this.opts.openOnEnter === false) {
+                        return;
+                    } else if (e.altKey || e.ctrlKey || e.shiftKey || e.metaKey) {
+                        return;
+                    }
+                }
+
+                this.open();
+
+                if (e.which === KEY.PAGE_UP || e.which === KEY.PAGE_DOWN) {
+                    // prevent the page from scrolling
+                    killEvent(e);
+                }
+            }));
+
+            this.search.bind("keyup", this.bind(this.resizeSearch));
+
+            this.search.bind("blur", this.bind(function(e) {
+                this.container.removeClass("select2-container-active");
+                this.search.removeClass("select2-focused");
+                if (!this.opened()) this.clearSearch();
+                e.stopImmediatePropagation();
+            }));
+
+            this.container.delegate(selector, "mousedown", this.bind(function (e) {
+                if (!this.enabled) return;
+                if ($(e.target).closest(".select2-search-choice").length > 0) {
+                    // clicked inside a select2 search choice, do not open
+                    return;
+                }
+                this.clearPlaceholder();
+                this.open();
+                this.focusSearch();
+                e.preventDefault();
+            }));
+
+            this.container.delegate(selector, "focus", this.bind(function () {
+                if (!this.enabled) return;
+                this.container.addClass("select2-container-active");
+                this.dropdown.addClass("select2-drop-active");
+                this.clearPlaceholder();
+            }));
+
+            this.initContainerWidth();
+
+            // set the placeholder if necessary
+            this.clearSearch();
+        },
+
+        // multi
+        enable: function() {
+            if (this.enabled) return;
+
+            this.parent.enable.apply(this, arguments);
+
+            this.search.removeAttr("disabled");
+        },
+
+        // multi
+        disable: function() {
+            if (!this.enabled) return;
+
+            this.parent.disable.apply(this, arguments);
+
+            this.search.attr("disabled", true);
+        },
+
+        // multi
+        initSelection: function () {
+            var data;
+            if (this.opts.element.val() === "" && this.opts.element.text() === "") {
+                this.updateSelection([]);
+                this.close();
+                // set the placeholder if necessary
+                this.clearSearch();
+            }
+            if (this.select || this.opts.element.val() !== "") {
+                var self = this;
+                this.opts.initSelection.call(null, this.opts.element, function(data){
+                    if (data !== undefined && data !== null) {
+                        self.updateSelection(data);
+                        self.close();
+                        // set the placeholder if necessary
+                        self.clearSearch();
+                    }
+                });
+            }
+        },
+
+        // multi
+        clearSearch: function () {
+            var placeholder = this.getPlaceholder();
+
+            if (placeholder !== undefined  && this.getVal().length === 0 && this.search.hasClass("select2-focused") === false) {
+                this.search.val(placeholder).addClass("select2-default");
+                // stretch the search box to full width of the container so as much of the placeholder is visible as possible
+                this.resizeSearch();
+            } else {
+                this.search.val("").width(10);
+            }
+        },
+
+        // multi
+        clearPlaceholder: function () {
+            if (this.search.hasClass("select2-default")) {
+                this.search.val("").removeClass("select2-default");
+            }
+        },
+
+        // multi
+        opening: function () {
+            this.parent.opening.apply(this, arguments);
+
+            this.clearPlaceholder();
+			this.resizeSearch();
+            this.focusSearch();
+
+            this.opts.element.trigger($.Event("open"));
+        },
+
+        // multi
+        close: function () {
+            if (!this.opened()) return;
+            this.parent.close.apply(this, arguments);
+        },
+
+        // multi
+        focus: function () {
+            this.close();
+            this.search.focus();
+            this.opts.element.triggerHandler("focus");
+        },
+
+        // multi
+        isFocused: function () {
+            return this.search.hasClass("select2-focused");
+        },
+
+        // multi
+        updateSelection: function (data) {
+            var ids = [], filtered = [], self = this;
+
+            // filter out duplicates
+            $(data).each(function () {
+                if (indexOf(self.id(this), ids) < 0) {
+                    ids.push(self.id(this));
+                    filtered.push(this);
+                }
+            });
+            data = filtered;
+
+            this.selection.find(".select2-search-choice").remove();
+            $(data).each(function () {
+                self.addSelectedChoice(this);
+            });
+            self.postprocessResults();
+        },
+
+        tokenize: function() {
+            var input = this.search.val();
+            input = this.opts.tokenizer(input, this.data(), this.bind(this.onSelect), this.opts);
+            if (input != null && input != undefined) {
+                this.search.val(input);
+                if (input.length > 0) {
+                    this.open();
+                }
+            }
+
+        },
+
+        // multi
+        onSelect: function (data, options) {
+            this.addSelectedChoice(data);
+
+            this.opts.element.trigger({ type: "selected", val: this.id(data), choice: data });
+
+            if (this.select || !this.opts.closeOnSelect) this.postprocessResults();
+
+            if (this.opts.closeOnSelect) {
+                this.close();
+                this.search.width(10);
+            } else {
+                if (this.countSelectableResults()>0) {
+                    this.search.width(10);
+                    this.resizeSearch();
+                    if (this.val().length >= this.getMaximumSelectionSize()) {
+                        // if we reached max selection size repaint the results so choices
+                        // are replaced with the max selection reached message
+                        this.updateResults(true);
+                    }
+                    this.positionDropdown();
+                } else {
+                    // if nothing left to select close
+                    this.close();
+                    this.search.width(10);
+                }
+            }
+
+            // since its not possible to select an element that has already been
+            // added we do not need to check if this is a new element before firing change
+            this.triggerChange({ added: data });
+
+            if (!options || !options.noFocus)
+                this.focusSearch();
+        },
+
+        // multi
+        cancel: function () {
+            this.close();
+            this.focusSearch();
+        },
+
+        addSelectedChoice: function (data) {
+            var enableChoice = !data.locked,
+                enabledItem = $(
+                    "<li class='select2-search-choice'>" +
+                    "    <div></div>" +
+                    "    <a href='#' onclick='return false;' class='select2-search-choice-close' tabindex='-1'></a>" +
+                    "</li>"),
+                disabledItem = $(
+                    "<li class='select2-search-choice select2-locked'>" +
+                    "<div></div>" +
+                    "</li>");
+            var choice = enableChoice ? enabledItem : disabledItem,
+                id = this.id(data),
+                val = this.getVal(),
+                formatted;
+
+            formatted=this.opts.formatSelection(data, choice.find("div"));
+            if (formatted != undefined) {
+                choice.find("div").replaceWith("<div>"+this.opts.escapeMarkup(formatted)+"</div>");
+            }
+
+            if(enableChoice){
+              choice.find(".select2-search-choice-close")
+                  .bind("mousedown", killEvent)
+                  .bind("click dblclick", this.bind(function (e) {
+                  if (!this.enabled) return;
+
+                  $(e.target).closest(".select2-search-choice").fadeOut('fast', this.bind(function(){
+                      this.unselect($(e.target));
+                      this.selection.find(".select2-search-choice-focus").removeClass("select2-search-choice-focus");
+                      this.close();
+                      this.focusSearch();
+                  })).dequeue();
+                  killEvent(e);
+              })).bind("focus", this.bind(function () {
+                  if (!this.enabled) return;
+                  this.container.addClass("select2-container-active");
+                  this.dropdown.addClass("select2-drop-active");
+              }));
+            }
+
+            choice.data("select2-data", data);
+            choice.insertBefore(this.searchContainer);
+
+            val.push(id);
+            this.setVal(val);
+        },
+
+        // multi
+        unselect: function (selected) {
+            var val = this.getVal(),
+                data,
+                index;
+
+            selected = selected.closest(".select2-search-choice");
+
+            if (selected.length === 0) {
+                throw "Invalid argument: " + selected + ". Must be .select2-search-choice";
+            }
+
+            data = selected.data("select2-data");
+
+            if (!data) {
+                // prevent a race condition when the 'x' is clicked really fast repeatedly the event can be queued
+                // and invoked on an element already removed
+                return;
+            }
+
+            index = indexOf(this.id(data), val);
+
+            if (index >= 0) {
+                val.splice(index, 1);
+                this.setVal(val);
+                if (this.select) this.postprocessResults();
+            }
+            selected.remove();
+
+            this.opts.element.trigger({ type: "removed", val: this.id(data), choice: data });
+            this.triggerChange({ removed: data });
+        },
+
+        // multi
+        postprocessResults: function () {
+            var val = this.getVal(),
+                choices = this.results.find(".select2-result"),
+                compound = this.results.find(".select2-result-with-children"),
+                self = this;
+
+            choices.each2(function (i, choice) {
+                var id = self.id(choice.data("select2-data"));
+                if (indexOf(id, val) >= 0) {
+                    choice.addClass("select2-selected");
+                    // mark all children of the selected parent as selected
+                    choice.find(".select2-result-selectable").addClass("select2-selected");
+                }
+            });
+
+            compound.each2(function(i, choice) {
+                // hide an optgroup if it doesnt have any selectable children
+                if (!choice.is('.select2-result-selectable')
+                    && choice.find(".select2-result-selectable:not(.select2-selected)").length === 0) {
+                    choice.addClass("select2-selected");
+                }
+            });
+
+            if (this.highlight() == -1){
+                self.highlight(0);
+            }
+
+        },
+
+        // multi
+        resizeSearch: function () {
+            var minimumWidth, left, maxWidth, containerLeft, searchWidth,
+            	sideBorderPadding = getSideBorderPadding(this.search);
+
+            minimumWidth = measureTextWidth(this.search) + 10;
+
+            left = this.search.offset().left;
+
+            maxWidth = this.selection.width();
+            containerLeft = this.selection.offset().left;
+
+            searchWidth = maxWidth - (left - containerLeft) - sideBorderPadding;
+
+            if (searchWidth < minimumWidth) {
+                searchWidth = maxWidth - sideBorderPadding;
+            }
+
+            if (searchWidth < 40) {
+                searchWidth = maxWidth - sideBorderPadding;
+            }
+
+            if (searchWidth <= 0) {
+              searchWidth = minimumWidth;
+            }
+
+            this.search.width(searchWidth);
+        },
+
+        // multi
+        getVal: function () {
+            var val;
+            if (this.select) {
+                val = this.select.val();
+                return val === null ? [] : val;
+            } else {
+                val = this.opts.element.val();
+                return splitVal(val, this.opts.separator);
+            }
+        },
+
+        // multi
+        setVal: function (val) {
+            var unique;
+            if (this.select) {
+                this.select.val(val);
+            } else {
+                unique = [];
+                // filter out duplicates
+                $(val).each(function () {
+                    if (indexOf(this, unique) < 0) unique.push(this);
+                });
+                this.opts.element.val(unique.length === 0 ? "" : unique.join(this.opts.separator));
+            }
+        },
+
+        // multi
+        val: function () {
+            var val, triggerChange = false, data = [], self=this;
+
+            if (arguments.length === 0) {
+                return this.getVal();
+            }
+
+            val = arguments[0];
+
+            if (arguments.length > 1) {
+                triggerChange = arguments[1];
+            }
+
+            // val is an id. !val is true for [undefined,null,'',0] - 0 is legal
+            if (!val && val !== 0) {
+                this.opts.element.val("");
+                this.updateSelection([]);
+                this.clearSearch();
+                if (triggerChange) {
+                    this.triggerChange();
+                }
+                return;
+            }
+
+            // val is a list of ids
+            this.setVal(val);
+
+            if (this.select) {
+                this.opts.initSelection(this.select, this.bind(this.updateSelection));
+                if (triggerChange) {
+                    this.triggerChange();
+                }
+            } else {
+                if (this.opts.initSelection === undefined) {
+                    throw new Error("val() cannot be called if initSelection() is not defined");
+                }
+
+                this.opts.initSelection(this.opts.element, function(data){
+                    var ids=$(data).map(self.id);
+                    self.setVal(ids);
+                    self.updateSelection(data);
+                    self.clearSearch();
+                    if (triggerChange) {
+                        self.triggerChange();
+                    }
+                });
+            }
+            this.clearSearch();
+        },
+
+        // multi
+        onSortStart: function() {
+            if (this.select) {
+                throw new Error("Sorting of elements is not supported when attached to <select>. Attach to <input type='hidden'/> instead.");
+            }
+
+            // collapse search field into 0 width so its container can be collapsed as well
+            this.search.width(0);
+            // hide the container
+            this.searchContainer.hide();
+        },
+
+        // multi
+        onSortEnd:function() {
+
+            var val=[], self=this;
+
+            // show search and move it to the end of the list
+            this.searchContainer.show();
+            // make sure the search container is the last item in the list
+            this.searchContainer.appendTo(this.searchContainer.parent());
+            // since we collapsed the width in dragStarted, we resize it here
+            this.resizeSearch();
+
+            // update selection
+
+            this.selection.find(".select2-search-choice").each(function() {
+                val.push(self.opts.id($(this).data("select2-data")));
+            });
+            this.setVal(val);
+            this.triggerChange();
+        },
+
+        // multi
+        data: function(values) {
+            var self=this, ids;
+            if (arguments.length === 0) {
+                 return this.selection
+                     .find(".select2-search-choice")
+                     .map(function() { return $(this).data("select2-data"); })
+                     .get();
+            } else {
+                if (!values) { values = []; }
+                ids = $.map(values, function(e) { return self.opts.id(e); });
+                this.setVal(ids);
+                this.updateSelection(values);
+                this.clearSearch();
+            }
+        }
+    });
+
+    $.fn.select2 = function () {
+
+        var args = Array.prototype.slice.call(arguments, 0),
+            opts,
+            select2,
+            value, multiple, allowedMethods = ["val", "destroy", "opened", "open", "close", "focus", "isFocused", "container", "onSortStart", "onSortEnd", "enable", "disable", "positionDropdown", "data"];
+
+        this.each(function () {
+            if (args.length === 0 || typeof(args[0]) === "object") {
+                opts = args.length === 0 ? {} : $.extend({}, args[0]);
+                opts.element = $(this);
+
+                if (opts.element.get(0).tagName.toLowerCase() === "select") {
+                    multiple = opts.element.attr("multiple");
+                } else {
+                    multiple = opts.multiple || false;
+                    if ("tags" in opts) {opts.multiple = multiple = true;}
+                }
+
+                select2 = multiple ? new MultiSelect2() : new SingleSelect2();
+                select2.init(opts);
+            } else if (typeof(args[0]) === "string") {
+
+                if (indexOf(args[0], allowedMethods) < 0) {
+                    throw "Unknown method: " + args[0];
+                }
+
+                value = undefined;
+                select2 = $(this).data("select2");
+                if (select2 === undefined) return;
+                if (args[0] === "container") {
+                    value=select2.container;
+                } else {
+                    value = select2[args[0]].apply(select2, args.slice(1));
+                }
+                if (value !== undefined) {return false;}
+            } else {
+                throw "Invalid arguments to select2 plugin: " + args;
+            }
+        });
+        return (value === undefined) ? this : value;
+    };
+
+    // plugin defaults, accessible to users
+    $.fn.select2.defaults = {
+        width: "copy",
+        loadMorePadding: 0,
+        closeOnSelect: true,
+        openOnEnter: true,
+        containerCss: {},
+        dropdownCss: {},
+        containerCssClass: "",
+        dropdownCssClass: "",
+        formatResult: function(result, container, query, escapeMarkup) {
+            var markup=[];
+            markMatch(result.text, query.term, markup, escapeMarkup);
+            return markup.join("");
+        },
+        formatSelection: function (data, container) {
+            return data ? data.text : undefined;
+        },
+        sortResults: function (results, container, query) {
+            return results;
+        },
+        formatResultCssClass: function(data) {return undefined;},
+        formatNoMatches: function () { return "No matches found"; },
+        formatInputTooShort: function (input, min) { var n = min - input.length; return "Please enter " + n + " more character" + (n == 1? "" : "s"); },
+        formatInputTooLong: function (input, max) { var n = input.length - max; return "Please enter " + n + " less character" + (n == 1? "" : "s"); },
+        formatSelectionTooBig: function (limit) { return "You can only select " + limit + " item" + (limit == 1 ? "" : "s"); },
+        formatLoadMore: function (pageNumber) { return "Loading more results..."; },
+        formatSearching: function () { return "Searching..."; },
+        minimumResultsForSearch: 0,
+        minimumInputLength: 0,
+        maximumInputLength: null,
+        maximumSelectionSize: 0,
+        id: function (e) { return e.id; },
+        matcher: function(term, text) {
+            return text.toUpperCase().indexOf(term.toUpperCase()) >= 0;
+        },
+        separator: ",",
+        tokenSeparators: [],
+        tokenizer: defaultTokenizer,
+        escapeMarkup: function (markup) {
+            var replace_map = {
+                '\\': '&#92;',
+                '&': '&amp;',
+                '<': '&lt;',
+                '>': '&gt;',
+                '"': '&quot;',
+                "'": '&apos;',
+                "/": '&#47;'
+            };
+
+            return String(markup).replace(/[&<>"'/\\]/g, function (match) {
+                    return replace_map[match[0]];
+            });
+        },
+        blurOnChange: false,
+        selectOnBlur: false,
+        adaptContainerCssClass: function(c) { return c; },
+        adaptDropdownCssClass: function(c) { return null; }
+    };
+
+    // exports
+    window.Select2 = {
+        query: {
+            ajax: ajax,
+            local: local,
+            tags: tags
+        }, util: {
+            debounce: debounce,
+            markMatch: markMatch
+        }, "class": {
+            "abstract": AbstractSelect2,
+            "single": SingleSelect2,
+            "multi": MultiSelect2
+        }
+    };
+
+}(jQuery));
diff --git a/module/web/static/js/libs/text-2.0.3.js b/module/web/static/js/libs/text-2.0.3.js
new file mode 100644
index 000000000..bf61a3fe4
--- /dev/null
+++ b/module/web/static/js/libs/text-2.0.3.js
@@ -0,0 +1,308 @@
+/**
+ * @license RequireJS text 2.0.3 Copyright (c) 2010-2012, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/requirejs/text for details
+ */
+/*jslint regexp: true */
+/*global require: false, XMLHttpRequest: false, ActiveXObject: false,
+  define: false, window: false, process: false, Packages: false,
+  java: false, location: false */
+
+define(['module'], function (module) {
+    'use strict';
+
+    var text, fs,
+        progIds = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0'],
+        xmlRegExp = /^\s*<\?xml(\s)+version=[\'\"](\d)*.(\d)*[\'\"](\s)*\?>/im,
+        bodyRegExp = /<body[^>]*>\s*([\s\S]+)\s*<\/body>/im,
+        hasLocation = typeof location !== 'undefined' && location.href,
+        defaultProtocol = hasLocation && location.protocol && location.protocol.replace(/\:/, ''),
+        defaultHostName = hasLocation && location.hostname,
+        defaultPort = hasLocation && (location.port || undefined),
+        buildMap = [],
+        masterConfig = (module.config && module.config()) || {};
+
+    text = {
+        version: '2.0.3',
+
+        strip: function (content) {
+            //Strips <?xml ...?> declarations so that external SVG and XML
+            //documents can be added to a document without worry. Also, if the string
+            //is an HTML document, only the part inside the body tag is returned.
+            if (content) {
+                content = content.replace(xmlRegExp, "");
+                var matches = content.match(bodyRegExp);
+                if (matches) {
+                    content = matches[1];
+                }
+            } else {
+                content = "";
+            }
+            return content;
+        },
+
+        jsEscape: function (content) {
+            return content.replace(/(['\\])/g, '\\$1')
+                .replace(/[\f]/g, "\\f")
+                .replace(/[\b]/g, "\\b")
+                .replace(/[\n]/g, "\\n")
+                .replace(/[\t]/g, "\\t")
+                .replace(/[\r]/g, "\\r")
+                .replace(/[\u2028]/g, "\\u2028")
+                .replace(/[\u2029]/g, "\\u2029");
+        },
+
+        createXhr: masterConfig.createXhr || function () {
+            //Would love to dump the ActiveX crap in here. Need IE 6 to die first.
+            var xhr, i, progId;
+            if (typeof XMLHttpRequest !== "undefined") {
+                return new XMLHttpRequest();
+            } else if (typeof ActiveXObject !== "undefined") {
+                for (i = 0; i < 3; i += 1) {
+                    progId = progIds[i];
+                    try {
+                        xhr = new ActiveXObject(progId);
+                    } catch (e) {}
+
+                    if (xhr) {
+                        progIds = [progId];  // so faster next time
+                        break;
+                    }
+                }
+            }
+
+            return xhr;
+        },
+
+        /**
+         * Parses a resource name into its component parts. Resource names
+         * look like: module/name.ext!strip, where the !strip part is
+         * optional.
+         * @param {String} name the resource name
+         * @returns {Object} with properties "moduleName", "ext" and "strip"
+         * where strip is a boolean.
+         */
+        parseName: function (name) {
+            var strip = false, index = name.indexOf("."),
+                modName = name.substring(0, index),
+                ext = name.substring(index + 1, name.length);
+
+            index = ext.indexOf("!");
+            if (index !== -1) {
+                //Pull off the strip arg.
+                strip = ext.substring(index + 1, ext.length);
+                strip = strip === "strip";
+                ext = ext.substring(0, index);
+            }
+
+            return {
+                moduleName: modName,
+                ext: ext,
+                strip: strip
+            };
+        },
+
+        xdRegExp: /^((\w+)\:)?\/\/([^\/\\]+)/,
+
+        /**
+         * Is an URL on another domain. Only works for browser use, returns
+         * false in non-browser environments. Only used to know if an
+         * optimized .js version of a text resource should be loaded
+         * instead.
+         * @param {String} url
+         * @returns Boolean
+         */
+        useXhr: function (url, protocol, hostname, port) {
+            var uProtocol, uHostName, uPort,
+                match = text.xdRegExp.exec(url);
+            if (!match) {
+                return true;
+            }
+            uProtocol = match[2];
+            uHostName = match[3];
+
+            uHostName = uHostName.split(':');
+            uPort = uHostName[1];
+            uHostName = uHostName[0];
+
+            return (!uProtocol || uProtocol === protocol) &&
+                   (!uHostName || uHostName.toLowerCase() === hostname.toLowerCase()) &&
+                   ((!uPort && !uHostName) || uPort === port);
+        },
+
+        finishLoad: function (name, strip, content, onLoad) {
+            content = strip ? text.strip(content) : content;
+            if (masterConfig.isBuild) {
+                buildMap[name] = content;
+            }
+            onLoad(content);
+        },
+
+        load: function (name, req, onLoad, config) {
+            //Name has format: some.module.filext!strip
+            //The strip part is optional.
+            //if strip is present, then that means only get the string contents
+            //inside a body tag in an HTML string. For XML/SVG content it means
+            //removing the <?xml ...?> declarations so the content can be inserted
+            //into the current doc without problems.
+
+            // Do not bother with the work if a build and text will
+            // not be inlined.
+            if (config.isBuild && !config.inlineText) {
+                onLoad();
+                return;
+            }
+
+            masterConfig.isBuild = config.isBuild;
+
+            var parsed = text.parseName(name),
+                nonStripName = parsed.moduleName + '.' + parsed.ext,
+                url = req.toUrl(nonStripName),
+                useXhr = (masterConfig.useXhr) ||
+                         text.useXhr;
+
+            //Load the text. Use XHR if possible and in a browser.
+            if (!hasLocation || useXhr(url, defaultProtocol, defaultHostName, defaultPort)) {
+                text.get(url, function (content) {
+                    text.finishLoad(name, parsed.strip, content, onLoad);
+                }, function (err) {
+                    if (onLoad.error) {
+                        onLoad.error(err);
+                    }
+                });
+            } else {
+                //Need to fetch the resource across domains. Assume
+                //the resource has been optimized into a JS module. Fetch
+                //by the module name + extension, but do not include the
+                //!strip part to avoid file system issues.
+                req([nonStripName], function (content) {
+                    text.finishLoad(parsed.moduleName + '.' + parsed.ext,
+                                    parsed.strip, content, onLoad);
+                });
+            }
+        },
+
+        write: function (pluginName, moduleName, write, config) {
+            if (buildMap.hasOwnProperty(moduleName)) {
+                var content = text.jsEscape(buildMap[moduleName]);
+                write.asModule(pluginName + "!" + moduleName,
+                               "define(function () { return '" +
+                                   content +
+                               "';});\n");
+            }
+        },
+
+        writeFile: function (pluginName, moduleName, req, write, config) {
+            var parsed = text.parseName(moduleName),
+                nonStripName = parsed.moduleName + '.' + parsed.ext,
+                //Use a '.js' file name so that it indicates it is a
+                //script that can be loaded across domains.
+                fileName = req.toUrl(parsed.moduleName + '.' +
+                                     parsed.ext) + '.js';
+
+            //Leverage own load() method to load plugin value, but only
+            //write out values that do not have the strip argument,
+            //to avoid any potential issues with ! in file names.
+            text.load(nonStripName, req, function (value) {
+                //Use own write() method to construct full module value.
+                //But need to create shell that translates writeFile's
+                //write() to the right interface.
+                var textWrite = function (contents) {
+                    return write(fileName, contents);
+                };
+                textWrite.asModule = function (moduleName, contents) {
+                    return write.asModule(moduleName, fileName, contents);
+                };
+
+                text.write(pluginName, nonStripName, textWrite, config);
+            }, config);
+        }
+    };
+
+    if (masterConfig.env === 'node' || (!masterConfig.env &&
+            typeof process !== "undefined" &&
+            process.versions &&
+            !!process.versions.node)) {
+        //Using special require.nodeRequire, something added by r.js.
+        fs = require.nodeRequire('fs');
+
+        text.get = function (url, callback) {
+            var file = fs.readFileSync(url, 'utf8');
+            //Remove BOM (Byte Mark Order) from utf8 files if it is there.
+            if (file.indexOf('\uFEFF') === 0) {
+                file = file.substring(1);
+            }
+            callback(file);
+        };
+    } else if (masterConfig.env === 'xhr' || (!masterConfig.env &&
+            text.createXhr())) {
+        text.get = function (url, callback, errback) {
+            var xhr = text.createXhr();
+            xhr.open('GET', url, true);
+
+            //Allow overrides specified in config
+            if (masterConfig.onXhr) {
+                masterConfig.onXhr(xhr, url);
+            }
+
+            xhr.onreadystatechange = function (evt) {
+                var status, err;
+                //Do not explicitly handle errors, those should be
+                //visible via console output in the browser.
+                if (xhr.readyState === 4) {
+                    status = xhr.status;
+                    if (status > 399 && status < 600) {
+                        //An http 4xx or 5xx error. Signal an error.
+                        err = new Error(url + ' HTTP status: ' + status);
+                        err.xhr = xhr;
+                        errback(err);
+                    } else {
+                        callback(xhr.responseText);
+                    }
+                }
+            };
+            xhr.send(null);
+        };
+    } else if (masterConfig.env === 'rhino' || (!masterConfig.env &&
+            typeof Packages !== 'undefined' && typeof java !== 'undefined')) {
+        //Why Java, why is this so awkward?
+        text.get = function (url, callback) {
+            var stringBuffer, line,
+                encoding = "utf-8",
+                file = new java.io.File(url),
+                lineSeparator = java.lang.System.getProperty("line.separator"),
+                input = new java.io.BufferedReader(new java.io.InputStreamReader(new java.io.FileInputStream(file), encoding)),
+                content = '';
+            try {
+                stringBuffer = new java.lang.StringBuffer();
+                line = input.readLine();
+
+                // Byte Order Mark (BOM) - The Unicode Standard, version 3.0, page 324
+                // http://www.unicode.org/faq/utf_bom.html
+
+                // Note that when we use utf-8, the BOM should appear as "EF BB BF", but it doesn't due to this bug in the JDK:
+                // http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4508058
+                if (line && line.length() && line.charAt(0) === 0xfeff) {
+                    // Eat the BOM, since we've already found the encoding on this file,
+                    // and we plan to concatenating this buffer with others; the BOM should
+                    // only appear at the top of a file.
+                    line = line.substring(1);
+                }
+
+                stringBuffer.append(line);
+
+                while ((line = input.readLine()) !== null) {
+                    stringBuffer.append(lineSeparator);
+                    stringBuffer.append(line);
+                }
+                //Make sure we return a JavaScript string and not a Java string.
+                content = String(stringBuffer.toString()); //String
+            } finally {
+                input.close();
+            }
+            callback(content);
+        };
+    }
+
+    return text;
+});
diff --git a/module/web/static/js/models/File.js b/module/web/static/js/models/File.js
new file mode 100644
index 000000000..524637cb4
--- /dev/null
+++ b/module/web/static/js/models/File.js
@@ -0,0 +1,91 @@
+define(['jquery', 'backbone', 'underscore', 'app', 'utils/apitypes'], function($, Backbone, _, App, Api) {
+
+    var Finished = [Api.DownloadStatus.Finished, Api.DownloadStatus.Skipped];
+    var Failed = [Api.DownloadStatus.Failed, Api.DownloadStatus.Aborted, Api.DownloadStatus.TempOffline, Api.DownloadStatus.Offline];
+    // Unfinished - Other
+
+    return Backbone.Model.extend({
+
+        idAttribute: 'fid',
+
+        defaults: {
+            fid: -1,
+            name: null,
+            package: -1,
+            owner: -1,
+            size: -1,
+            status: -1,
+            media: -1,
+            added: -1,
+            fileorder: -1,
+            download: null,
+
+            // UI attributes
+            selected: false,
+            visible: true,
+            progress: 0,
+            eta: 0
+        },
+
+        // Model Constructor
+        initialize: function() {
+
+        },
+
+        fetch: function(options) {
+            options = App.apiRequest(
+                'getFileInfo',
+                {fid: this.get('fid')},
+                options);
+
+            return Backbone.Model.prototype.fetch.call(this, options);
+        },
+
+        destroy: function(options) {
+            // also not working when using data
+            options = App.apiRequest(
+                'deleteFiles/[' + this.get('fid') + ']',
+                null, options);
+            options.method = "post";
+
+            return Backbone.Model.prototype.destroy.call(this, options);
+        },
+
+        // Does not send a request to the server
+        destroyLocal: function(options) {
+            this.trigger('destroy', this, this.collection, options);
+        },
+
+        restart: function(options) {
+            options = App.apiRequest(
+                'restartFile',
+                {fid: this.get('fid')},
+                options);
+
+            return $.ajax(options);
+        },
+
+        // Any time a model attribute is set, this method is called
+        validate: function(attrs) {
+
+        },
+
+        isDownload: function() {
+            return this.has('download');
+        },
+
+        isFinished: function() {
+            return _.indexOf(Finished, this.get('download').status) > -1;
+        },
+
+        isUnfinished: function() {
+            return _.indexOf(Finished, this.get('download').status) === -1 && _.indexOf(Failed, this.get('download').status) === -1;
+        },
+
+        isFailed: function() {
+            return _.indexOf(Failed, this.get('download').status) > -1;
+        }
+
+    });
+
+});
\ No newline at end of file
diff --git a/module/web/static/js/models/InteractionTask.js b/module/web/static/js/models/InteractionTask.js
new file mode 100644
index 000000000..56fdbf8bf
--- /dev/null
+++ b/module/web/static/js/models/InteractionTask.js
@@ -0,0 +1,40 @@
+define(['jquery', 'backbone', 'underscore', 'app', 'utils/apitypes'],
+    function($, Backbone, _, App, Api) {
+
+        return Backbone.Model.extend({
+
+            idAttribute: 'iid',
+
+            defaults: {
+                iid: -1,
+                type: null,
+                input: null,
+                default_value: null,
+                title: "",
+                description: "",
+                plugin: "",
+                // additional attributes
+                result: ""
+            },
+
+            // Model Constructor
+            initialize: function() {
+
+            },
+
+            save: function(options) {
+                options = App.apiRequest('setInteractionResult/' + this.get('iid'),
+                    {result: this.get('result')}, options);
+
+                return $.ajax(options);
+            },
+
+            isNotification: function() {
+                return this.get('type') === Api.Interaction.Notification;
+            },
+
+            isCaptcha: function() {
+                return this.get('type') === Api.Interaction.Captcha;
+            }
+        });
+    });
\ No newline at end of file
diff --git a/module/web/static/js/models/Package.js b/module/web/static/js/models/Package.js
new file mode 100644
index 000000000..1b050d735
--- /dev/null
+++ b/module/web/static/js/models/Package.js
@@ -0,0 +1,118 @@
+define(['jquery', 'backbone', 'underscore', 'app', 'collections/FileList', 'require'],
+    function($, Backbone, _, App, FileList, require) {
+
+        return Backbone.Model.extend({
+
+            idAttribute: 'pid',
+
+            defaults: {
+                pid: -1,
+                name: null,
+                folder: "",
+                root: -1,
+                owner: -1,
+                site: "",
+                comment: "",
+                password: "",
+                added: -1,
+                tags: null,
+                status: -1,
+                shared: false,
+                packageorder: -1,
+                stats: null,
+                fids: null,
+                pids: null,
+                files: null, // Collection
+                packs: null, // Collection
+
+                selected: false // For Checkbox
+            },
+
+            // Model Constructor
+            initialize: function() {
+            },
+
+            toJSON: function(options) {
+                var obj = Backbone.Model.prototype.toJSON.call(this, options);
+                obj.percent = Math.round(obj.stats.linksdone * 100 / obj.stats.linkstotal);
+
+                return obj;
+            },
+
+            // Changes url + method and delegates call to super class
+            fetch: function(options) {
+                options = App.apiRequest(
+                    'getFileTree/' + this.get('pid'),
+                    {full: false},
+                    options);
+
+                return Backbone.Model.prototype.fetch.call(this, options);
+            },
+
+            // Create a pseudo package und use search to populate data
+            search: function(qry, options) {
+                options = App.apiRequest(
+                    'findFiles',
+                    {pattern: qry},
+                    options);
+
+                return Backbone.Model.prototype.fetch.call(this, options);
+            },
+
+            save: function(options) {
+                // TODO
+            },
+
+            destroy: function(options) {
+                // TODO: Not working when using data?, array seems to break it
+                options = App.apiRequest(
+                    'deletePackages/[' + this.get('pid') + ']',
+                    null, options);
+                options.method = 'post';
+
+                console.log(options);
+
+                return Backbone.Model.prototype.destroy.call(this, options);
+            },
+
+            restart: function(options) {
+                options = App.apiRequest(
+                    'restartPackage',
+                    {pid: this.get('pid')},
+                    options);
+
+                var self = this;
+                options.success = function() {
+                    self.fetch();
+                };
+                return $.ajax(options);
+            },
+
+            parse: function(resp) {
+                // Package is loaded from tree collection
+                if (_.has(resp, 'root')) {
+                    if (!this.has('files'))
+                        resp.root.files = new FileList(_.values(resp.files));
+                    else
+                        this.get('files').update(_.values(resp.files));
+
+                    // circular dependencies needs to be avoided
+                    var PackageList = require('collections/PackageList');
+
+                    if (!this.has('packs'))
+                        resp.root.packs = new PackageList(_.values(resp.packages));
+                    else
+                        this.get('packs').update(_.values(resp.packages));
+
+                    return resp.root;
+                }
+                return Backbone.model.prototype.parse.call(this, resp);
+            },
+
+            // Any time a model attribute is set, this method is called
+            validate: function(attrs) {
+
+            }
+
+        });
+    });
\ No newline at end of file
diff --git a/module/web/static/js/models/Progress.js b/module/web/static/js/models/Progress.js
new file mode 100644
index 000000000..96beb0198
--- /dev/null
+++ b/module/web/static/js/models/Progress.js
@@ -0,0 +1,49 @@
+define(['jquery', 'backbone', 'underscore', 'utils/apitypes'], function($, Backbone, _, Api) {
+
+    return Backbone.Model.extend({
+
+        // generated, not submitted
+        idAttribute: 'pid',
+
+        defaults: {
+            pid: -1,
+            plugin: null,
+            name: null,
+            statusmsg: -1,
+            eta: -1,
+            done: -1,
+            total: -1,
+            download: null
+        },
+
+        getPercent: function() {
+            if (this.get('total') > 0)
+                return Math.round(this.get('done') * 100 / this.get('total'));
+            return  0;
+        },
+
+        // Model Constructor
+        initialize: function() {
+
+        },
+
+        // Any time a model attribute is set, this method is called
+        validate: function(attrs) {
+
+        },
+
+        toJSON: function(options) {
+            var obj = Backbone.Model.prototype.toJSON.call(this, options);
+            obj.percent = this.getPercent();
+            obj.downloading = this.isDownload() && this.get('download').status === Api.DownloadStatus.Downloading;
+
+            return obj;
+        },
+
+        isDownload : function() {
+            return this.has('download');
+        }
+
+    });
+
+});
\ No newline at end of file
diff --git a/module/web/static/js/models/ServerStatus.js b/module/web/static/js/models/ServerStatus.js
new file mode 100644
index 000000000..9242bdf95
--- /dev/null
+++ b/module/web/static/js/models/ServerStatus.js
@@ -0,0 +1,46 @@
+define(['jquery', 'backbone', 'underscore'],
+    function($, Backbone, _) {
+
+        return Backbone.Model.extend({
+
+            defaults: {
+                speed: 0,
+                linkstotal: 0,
+                linksqueue: 0,
+                sizetotal: 0,
+                sizequeue: 0,
+                notifications: -1,
+                paused: false,
+                download: false,
+                reconnect: false
+            },
+
+            // Model Constructor
+            initialize: function() {
+
+            },
+
+            fetch: function() {
+                options || (options = {});
+                options.url = 'api/getServerStatus';
+
+                return Backbone.Model.prototype.fetch.call(this, options);
+            },
+
+            toJSON: function(options) {
+                var obj = Backbone.Model.prototype.toJSON.call(this, options);
+
+                obj.linksdone = obj.linkstotal - obj.linksqueue;
+                obj.sizedone = obj.sizetotal - obj.sizequeue;
+                if (obj.speed && obj.speed > 0)
+                    obj.eta = Math.round(obj.sizequeue / obj.speed);
+                else if (obj.sizequeue > 0)
+                    obj.eta = Infinity;
+                else
+                    obj.eta = 0;
+
+                return obj;
+            }
+
+        });
+    });
\ No newline at end of file
diff --git a/module/web/static/js/models/TreeCollection.js b/module/web/static/js/models/TreeCollection.js
new file mode 100644
index 000000000..bf14478ce
--- /dev/null
+++ b/module/web/static/js/models/TreeCollection.js
@@ -0,0 +1,49 @@
+define(['jquery', 'backbone', 'underscore', 'app', 'models/Package', 'collections/FileList', 'collections/PackageList'],
+    function($, Backbone, _, App, Package, FileList, PackageList) {
+
+    // TreeCollection
+    // A Model and not a collection, aggregates other collections
+    return Backbone.Model.extend({
+
+        defaults : {
+            root: null,
+            packages: null,
+            files: null
+        },
+
+        initialize: function() {
+
+        },
+
+        fetch: function(options) {
+            options || (options = {});
+            var pid = options.pid || -1;
+
+            options = App.apiRequest(
+                'getFileTree/' + pid,
+                {full: false},
+                options);
+
+            console.log('Fetching package tree ' + pid);
+            return Backbone.Model.prototype.fetch.call(this, options);
+        },
+
+        // Parse the response and updates the collections
+        parse: function(resp) {
+            var ret = {};
+            if (!this.has('packages'))
+                ret.packages = new PackageList(_.values(resp.packages));
+            else
+                this.get('packages').update(_.values(resp.packages));
+
+            if (!this.has('files'))
+                ret.files = new FileList(_.values(resp.files));
+            else
+                this.get('files').update(_.values(resp.files));
+
+            ret.root = new Package(resp.root);
+            return ret;
+        }
+
+    });
+});
\ No newline at end of file
diff --git a/module/web/static/js/routers/defaultRouter.js b/module/web/static/js/routers/defaultRouter.js
new file mode 100644
index 000000000..95b8de967
--- /dev/null
+++ b/module/web/static/js/routers/defaultRouter.js
@@ -0,0 +1,29 @@
+define(['jquery','backbone','views/headerView'], function($, Backbone, HeaderView){
+
+    var Router = Backbone.Router.extend({
+
+        initialize: function(){
+            Backbone.history.start();
+        },
+
+        // All of your Backbone Routes (add more)
+        routes: {
+
+            // When there is no hash bang on the url, the home method is called
+            '': 'home'
+
+        },
+
+        'home': function(){
+            // Instantiating mainView and anotherView instances
+            var headerView = new HeaderView();
+
+            // Renders the mainView template
+            headerView.render();
+
+        }
+    });
+
+    // Returns the Router class
+    return Router;
+});
\ No newline at end of file
diff --git a/module/web/static/js/routers/mobileRouter.js b/module/web/static/js/routers/mobileRouter.js
new file mode 100644
index 000000000..7f1f7805e
--- /dev/null
+++ b/module/web/static/js/routers/mobileRouter.js
@@ -0,0 +1,55 @@
+define(['jquery','backbone', 'underscore'], function($, Backbone, _){
+
+    return Backbone.Router.extend({
+
+        initialize: function(){
+            _.bindAll(this, "changePage");
+
+            this.$el = $("#content");
+
+            // Tells Backbone to start watching for hashchange events
+            Backbone.history.start();
+
+        },
+
+        // All of your Backbone Routes (add more)
+        routes: {
+
+            // When there is no hash bang on the url, the home method is called
+            '': 'home'
+
+        },
+
+        'home': function(){
+
+            var self = this;
+
+            $("#p1").fastClick(function(){
+                self.changePage($("<div class='page' style='background-color: #9acd32;'><h1>Page 1</h1><br>some content<br>sdfdsf<br>sdffg<h3>oiuzz</h3></div>"));
+            });
+
+            $("#p2").bind("click", function(){
+                self.changePage($("<div class='page' style='background-color: blue;'><h1>Page 2</h1><br>some content<br>sdfdsf<br><h2>sdfsdf</h2>sdffg</div>"));
+            });
+
+        },
+
+        changePage: function(content){
+
+            var oldpage = this.$el.find(".page");
+            content.css({x: "100%"});
+            this.$el.append(content);
+            content.transition({x:0}, function(){
+                window.setTimeout(function(){
+                    oldpage.remove();
+                }, 400);
+            });
+
+//            $("#viewport").transition({x: "100%"}, function(){
+//                $("#viewport").html(content);
+//                $("#viewport").transition({x: 0});
+//            });
+        }
+
+    });
+});
\ No newline at end of file
diff --git a/module/web/static/js/utils/animations.js b/module/web/static/js/utils/animations.js
new file mode 100644
index 000000000..5131d3b8a
--- /dev/null
+++ b/module/web/static/js/utils/animations.js
@@ -0,0 +1,128 @@
+define(['jquery', 'underscore', 'transit'], function(jQuery, _) {
+
+    // Adds an element and computes its height, which is saved as data attribute
+    // Important function to have slide animations
+    jQuery.fn.appendWithHeight = function(element, hide) {
+        var o = jQuery(this[0]);
+        element = jQuery(element);
+
+        // TODO: additionally it could be placed out of viewport first
+        // The real height can only be retrieved when element is on DOM and display:true
+        element.css('visibility', 'hidden');
+        o.append(element);
+
+        var height = element.height();
+
+        // Hide the element
+        if (hide === true) {
+            element.hide();
+            element.height(0);
+        }
+
+        element.css('visibility', '');
+        element.data('height', height);
+
+        return this;
+    };
+
+    // Shortcut to have a animation when element is added
+    jQuery.fn.appendWithAnimation = function(element, animation) {
+        var o = jQuery(this[0]);
+        element = jQuery(element);
+
+        if (animation === true)
+            element.hide();
+
+        o.append(element);
+
+        if (animation === true)
+            element.fadeIn();
+
+//        element.calculateHeight();
+
+        return this;
+    };
+
+    // calculate the height and write it to data, should be used on invisible elements
+    jQuery.fn.calculateHeight = function(setHeight) {
+        var o = jQuery(this[0]);
+        var height = o.height();
+        if (!height) {
+            var display = o.css('display');
+            o.css('visibility', 'hidden');
+            o.show();
+            height = o.height();
+
+            o.css('display', display);
+            o.css('visibility', '');
+        }
+
+        if (setHeight)
+            o.css('height', height);
+
+        o.data('height', height);
+        return this;
+    };
+
+    // TODO: carry arguments, optional height argument
+
+    // reset arguments, sets overflow hidden
+    jQuery.fn.slideOut = function(reset) {
+        var o = jQuery(this[0]);
+        o.animate({height: o.data('height'), opacity: 'show'}, function() {
+            // reset css attributes;
+            if (reset) {
+                this.css('overflow', '');
+                this.css('height', '');
+            }
+        });
+        return this;
+    };
+
+    jQuery.fn.slideIn = function(reset) {
+        var o = jQuery(this[0]);
+        if (reset) {
+            o.css('overflow', 'hidden');
+        }
+        o.animate({height: 0, opacity: 'hide'});
+        return this;
+    };
+
+    jQuery.fn.initTooltips = function(placement) {
+        placement || (placement = 'top');
+
+        var o = jQuery(this[0]);
+        o.find('[data-toggle="tooltip"]').tooltip(
+            {
+                delay: {show: 800, hide: 100},
+                placement: placement
+            });
+
+        return this;
+    };
+
+    jQuery.fn._transit = jQuery.fn.transit;
+
+    // Overriding transit plugin to support hide and show
+    jQuery.fn.transit = jQuery.fn.transition = function(props, duration, easing, callback) {
+        var self = this;
+        var cb = callback;
+        var newprops = _.extend({}, props);
+
+        if (newprops && (newprops.opacity === 'hide')) {
+            newprops.opacity = 0;
+
+            callback = function() {
+                self.css({display: 'none'});
+                if (typeof cb === 'function') {
+                    cb.apply(self);
+                }
+            };
+        } else if (newprops && (newprops.opacity === 'show')) {
+            newprops.opacity = 1;
+            this.css({display: 'block'});
+        }
+
+        return this._transit(newprops, duration, easing, callback);
+    };
+});
\ No newline at end of file
diff --git a/module/web/static/js/utils/apitypes.js b/module/web/static/js/utils/apitypes.js
new file mode 100644
index 000000000..28620250e
--- /dev/null
+++ b/module/web/static/js/utils/apitypes.js
@@ -0,0 +1,14 @@
+// Autogenerated, do not edit!
+define([], function() {
+	return {
+		DownloadState: {'Failed': 3, 'All': 0, 'Unmanaged': 4, 'Finished': 1, 'Unfinished': 2},
+		DownloadStatus: {'Downloading': 10, 'NA': 0, 'Processing': 14, 'Waiting': 9, 'Decrypting': 13, 'Paused': 4, 'Failed': 7, 'Finished': 5, 'Skipped': 6, 'Unknown': 16, 'Aborted': 12, 'Online': 2, 'TempOffline': 11, 'Offline': 1, 'Custom': 15, 'Starting': 8, 'Queued': 3},
+		FileStatus: {'Remote': 2, 'Ok': 0, 'Missing': 1},
+		InputType: {'Multiple': 10, 'Int': 2, 'NA': 0, 'List': 11, 'Bool': 7, 'File': 3, 'Text': 1, 'Table': 12, 'Folder': 4, 'Password': 6, 'Click': 8, 'Select': 9, 'Textbox': 5},
+		Interaction: {'Captcha': 2, 'All': 0, 'Query': 4, 'Notification': 1},
+		MediaType: {'All': 0, 'Audio': 2, 'Image': 4, 'Other': 1, 'Video': 8, 'Document': 16, 'Archive': 32},
+		PackageStatus: {'Paused': 1, 'Remote': 3, 'Folder': 2, 'Ok': 0},
+		Permission: {'All': 0, 'Interaction': 32, 'Modify': 4, 'Add': 1, 'Accounts': 16, 'Plugins': 64, 'Download': 8, 'Delete': 2},
+		Role: {'Admin': 0, 'User': 1},
+	};
+});
\ No newline at end of file
diff --git a/module/web/static/js/utils/dialogs.js b/module/web/static/js/utils/dialogs.js
new file mode 100644
index 000000000..13478ff88
--- /dev/null
+++ b/module/web/static/js/utils/dialogs.js
@@ -0,0 +1,15 @@
+// Loads all helper and set own handlebars rules
+define(['jquery', 'underscore', 'views/abstract/modalView'], function($, _, modal) {
+
+    // Shows the confirm dialog for given context
+    // on success executes func with context
+    _.confirm = function(template, func, context) {
+        template = "text!tpl/" + template;
+        _.requireOnce([template], function(html) {
+            var template = _.compile(html);
+            var dialog = new modal(template, _.bind(func, context));
+            dialog.show();
+        });
+
+    };
+});
\ No newline at end of file
diff --git a/module/web/static/js/utils/initHB.js b/module/web/static/js/utils/initHB.js
new file mode 100644
index 000000000..c977f063d
--- /dev/null
+++ b/module/web/static/js/utils/initHB.js
@@ -0,0 +1,10 @@
+// Loads all helper and set own handlebars rules
+define(['underscore', 'handlebars',
+    'helpers/formatSize', 'helpers/fileHelper', 'helpers/formatTime'],
+    function(_, Handlebars) {
+        // Replace with own lexer rules compiled from handlebars.l
+        Handlebars.Parser.lexer.rules = [/^(?:[^\x00]*?(?=(<%)))/, /^(?:[^\x00]+)/, /^(?:[^\x00]{2,}?(?=(\{\{|$)))/, /^(?:\{\{>)/, /^(?:<%=)/, /^(?:<%\/)/, /^(?:\{\{\^)/, /^(?:<%\s*else\b)/, /^(?:\{<%%)/, /^(?:\{\{&)/, /^(?:<%![\s\S]*?%>)/, /^(?:<%)/, /^(?:=)/, /^(?:\.(?=[%} ]))/, /^(?:\.\.)/, /^(?:[\/.])/, /^(?:\s+)/, /^(?:%%>)/, /^(?:%>)/, /^(?:"(\\["]|[^"])*")/, /^(?:'(\\[']|[^'])*')/, /^(?:@[a-zA-Z]+)/, /^(?:true(?=[%}\s]))/, /^(?:false(?=[%}\s]))/, /^(?:[0-9]+(?=[%}\s]))/, /^(?:[a-zA-Z0-9_$-]+(?=[=%}\s\/.]))/, /^(?:\[[^\]]*\])/, /^(?:.)/, /^(?:$)/];
+        _.compile = Handlebars.compile;
+
+        return Handlebars;
+    });
\ No newline at end of file
diff --git a/module/web/static/js/utils/lazyRequire.js b/module/web/static/js/utils/lazyRequire.js
new file mode 100644
index 000000000..b381e0ce6
--- /dev/null
+++ b/module/web/static/js/utils/lazyRequire.js
@@ -0,0 +1,96 @@
+// Define the module.
+define(
+	[
+		"require", "underscore"
+	],
+	function( require, _ ){
+
+
+		// Define the states of loading for a given set of modules
+		// within a require() statement.
+		var states = {
+			unloaded: "UNLOADED",
+			loading: "LOADING",
+			loaded: "LOADED"
+		};
+
+
+		// Define the top-level module container. Mostly, we're making
+		// the top-level container a non-Function so that users won't
+		// try to invoke this without calling the once() method below.
+		var lazyRequire = {};
+
+
+		// I will return a new, unique instance of the requrieOnce()
+		// method. Each instance will only call the require() method
+		// once internally.
+		lazyRequire.once = function(){
+
+			// The modules start in an unloaded state before
+			// requireOnce() is invoked by the calling code.
+			var state = states.unloaded;
+            var args;
+
+			var requireOnce = function(dependencies, loadCallback ){
+
+				// Use the module state to determine which method to
+				// invoke (or just to ignore the invocation).
+				if (state === states.loaded){
+					loadCallback.apply(null, args);
+
+				// The modules have not yet been requested - let's
+				// lazy load them.
+				} else if (state !== states.loading){
+
+					// We're about to load the modules asynchronously;
+					// flag the interim state.
+					state = states.loading;
+
+					// Load the modules.
+					require(
+						dependencies,
+						function(){
+
+                            args = arguments;
+							loadCallback.apply( null, args );
+                            state = states.loaded;
+
+
+						}
+					);
+
+				// RequireJS is currently loading the modules
+				// asynchronously, but they have not finished
+				// loading yet.
+				} else {
+
+					// Simply ignore this call.
+					return;
+
+				}
+
+			};
+
+			// Return the new lazy loader.
+			return( requireOnce );
+
+		};
+
+
+		// -------------------------------------------------- //
+		// -------------------------------------------------- //
+
+        // Set up holder for underscore
+        var instances = {};
+        _.requireOnce = function(dependencies, loadCallback) {
+            if (!_.has(instances, dependencies))
+                instances[dependencies] = lazyRequire.once();
+
+            return instances[dependencies](dependencies, loadCallback)
+        };
+
+
+		// Return the module definition.
+		return( lazyRequire );
+	}
+);
\ No newline at end of file
diff --git a/module/web/static/js/utils/remaining.js b/module/web/static/js/utils/remaining.js
new file mode 100644
index 000000000..d66a2931a
--- /dev/null
+++ b/module/web/static/js/utils/remaining.js
@@ -0,0 +1,149 @@
+/**
+ * Javascript Countdown
+ * Copyright (c) 2009 Markus Hedlund
+ * Version 1.1
+ * Licensed under MIT license
+ * http://www.opensource.org/licenses/mit-license.php
+ * http://labs.mimmin.com/countdown
+ */
+define([], function() {
+    var remaining = {
+        /**
+         * Get the difference of the passed date, and now. The different formats of the taget parameter are:
+         * January 12, 2009 15:14:00     (Month dd, yyyy hh:mm:ss)
+         * January 12, 2009              (Month dd, yyyy)
+         * 09,00,12,15,14,00             (yy,mm,dd,hh,mm,ss) Months range from 0-11, not 1-12.
+         * 09,00,12                      (yy,mm,dd)          Months range from 0-11, not 1-12.
+         * 500                           (milliseconds)
+         * 2009-01-12 15:14:00           (yyyy-mm-dd hh-mm-ss)
+         * 2009-01-12 15:14              (yyyy-mm-dd hh-mm)
+         * @param target Target date. Can be either a date object or a string (formated like '24 December, 2010 15:00:00')
+         * @return Difference in seconds
+         */
+        getSeconds: function(target) {
+            var today = new Date();
+
+            if (typeof(target) == 'object') {
+                var targetDate = target;
+            } else {
+                var matches = target.match(/(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2})(:(\d{2}))?/);   // YYYY-MM-DD HH-MM-SS
+                if (matches != null) {
+                    matches[7] = typeof(matches[7]) == 'undefined' ? '00' : matches[7];
+                    var targetDate = new Date(matches[1], matches[2] - 1, matches[3], matches[4], matches[5], matches[7]);
+                } else {
+                    var targetDate = new Date(target);
+                }
+            }
+
+            return Math.floor((targetDate.getTime() - today.getTime()) / 1000);
+        },
+
+        /**
+         * @param seconds Difference in seconds
+         * @param i18n A language object (see code)
+         * @param onlyLargestUnit Return only the largest unit (see documentation)
+         * @param hideEmpty Hide empty units (see documentation)
+         * @return String formated something like '1 week, 1 hours, 1 second'
+         */
+        getString: function(seconds, i18n, onlyLargestUnit, hideEmpty) {
+            if (seconds < 1) {
+                return '';
+            }
+
+            if (typeof(hideEmpty) == 'undefined' || hideEmpty == null) {
+                hideEmpty = true;
+            }
+            if (typeof(onlyLargestUnit) == 'undefined' || onlyLargestUnit == null) {
+                onlyLargestUnit = false;
+            }
+            if (typeof(i18n) == 'undefined' || i18n == null) {
+                i18n = {
+                    weeks: ['week', 'weeks'],
+                    days: ['day', 'days'],
+                    hours: ['hour', 'hours'],
+                    minutes: ['minute', 'minutes'],
+                    seconds: ['second', 'seconds']
+                };
+            }
+
+            var units = {
+                weeks: 7 * 24 * 60 * 60,
+                days: 24 * 60 * 60,
+                hours: 60 * 60,
+                minutes: 60,
+                seconds: 1
+            };
+
+            var returnArray = [];
+            var value;
+            for (unit in units) {
+                value = units[unit];
+                if (seconds / value >= 1 || unit == 'seconds' || !hideEmpty) {
+                    secondsConverted = Math.floor(seconds / value);
+                    var i18nUnit = i18n[unit][secondsConverted == 1 ? 0 : 1];
+                    returnArray.push(secondsConverted + ' ' + i18nUnit);
+                    seconds -= secondsConverted * value;
+
+                    if (onlyLargestUnit) {
+                        break;
+                    }
+                }
+            }
+            ;
+
+            return returnArray.join(', ');
+        },
+
+        /**
+         * @param seconds Difference in seconds
+         * @return String formated something like '169:00:01'
+         */
+        getStringDigital: function(seconds) {
+            if (seconds < 1) {
+                return '';
+            }
+
+            remainingTime = remaining.getArray(seconds);
+
+            for (index in remainingTime) {
+                remainingTime[index] = remaining.padNumber(remainingTime[index]);
+            }
+            ;
+
+            return remainingTime.join(':');
+        },
+
+        /**
+         * @param seconds Difference in seconds
+         * @return Array with hours, minutes and seconds
+         */
+        getArray: function(seconds) {
+            if (seconds < 1) {
+                return [];
+            }
+
+            var units = [60 * 60, 60, 1];
+
+            var returnArray = [];
+            var value;
+            for (index in units) {
+                value = units[index];
+                secondsConverted = Math.floor(seconds / value);
+                returnArray.push(secondsConverted);
+                seconds -= secondsConverted * value;
+            }
+            ;
+
+            return returnArray;
+        },
+
+        /**
+         * @param number An integer
+         * @return Integer padded with a 0 if necessary
+         */
+        padNumber: function(number) {
+            return (number >= 0 && number < 10) ? '0' + number : number;
+        }
+    };
+    return remaining;
+});
\ No newline at end of file
diff --git a/module/web/static/js/views/abstract/itemView.js b/module/web/static/js/views/abstract/itemView.js
new file mode 100644
index 000000000..394044ec4
--- /dev/null
+++ b/module/web/static/js/views/abstract/itemView.js
@@ -0,0 +1,46 @@
+define(['jquery', 'backbone', 'underscore'], function($, Backbone, _) {
+
+    // A view that is meant for temporary displaying
+    // All events must be unbound in onDestroy
+    return Backbone.View.extend({
+
+        tagName: 'li',
+        destroy: function() {
+            this.undelegateEvents();
+            this.unbind();
+            if (this.onDestroy) {
+                this.onDestroy();
+            }
+            this.$el.removeData().unbind();
+            this.remove();
+        },
+
+        hide: function() {
+            this.$el.slideUp();
+        },
+
+        show: function() {
+            this.$el.slideDown();
+        },
+
+        unrender: function() {
+            var self = this;
+            this.$el.slideUp(function() {
+                self.destroy();
+            });
+        },
+
+        deleteItem: function(e) {
+            if (e)
+                e.stopPropagation();
+            this.model.destroy();
+        },
+
+        restart: function(e) {
+            if(e)
+                e.stopPropagation();
+            this.model.restart();
+        }
+
+    });
+});
\ No newline at end of file
diff --git a/module/web/static/js/views/abstract/modalView.js b/module/web/static/js/views/abstract/modalView.js
new file mode 100644
index 000000000..d3ac34bd6
--- /dev/null
+++ b/module/web/static/js/views/abstract/modalView.js
@@ -0,0 +1,115 @@
+define(['jquery', 'backbone', 'underscore', 'omniwindow'], function($, Backbone, _) {
+
+    return Backbone.View.extend({
+
+        events: {
+            'click .btn-confirm': 'confirm',
+            'click .btn-close': 'hide',
+            'click .close': 'hide'
+        },
+
+        template: null,
+        dialog: null,
+
+        onHideDestroy: false,
+        confirmCallback: null,
+
+        initialize: function(template, confirm) {
+            this.confirmCallback = confirm;
+            var self = this;
+            if (this.template === null) {
+                if (template) {
+                    this.template = template;
+                    // When template was provided this is a temporary dialog
+                    this.onHideDestroy = true;
+                }
+                else
+                    require(['text!tpl/default/modal.html'], function(template) {
+                        self.template = template;
+                    });
+            }
+
+        },
+
+        render: function() {
+            this.$el.html(this.template(this.renderContent()));
+            this.$el.addClass('modal hide');
+            this.$el.css({opacity: 0, scale: 0.7});
+            $("body").append(this.el);
+
+            var self = this;
+
+            this.dialog = this.$el.omniWindow({
+                overlay: {
+                    selector: '#modal-overlay',
+                    hideClass: 'hide',
+                    animations: {
+                        hide: function(subjects, internalCallback) {
+                            subjects.overlay.transition({opacity: 'hide', delay: 100}, 300, function() {
+                                internalCallback(subjects);
+                                if (self.onHideDestroy)
+                                    self.destroy();
+                            });
+                        },
+                        show: function(subjects, internalCallback) {
+                            subjects.overlay.fadeIn(300);
+                            internalCallback(subjects);
+                        }}},
+                modal: {
+                    hideClass: 'hide',
+                    animations: {
+                        hide: function(subjects, internalCallback) {
+                            subjects.modal.transition({opacity: 'hide', scale: 0.7}, 300);
+                            internalCallback(subjects);
+                        },
+
+                        show: function(subjects, internalCallback) {
+                            subjects.modal.transition({opacity: 'show', scale: 1, delay: 100}, 300, function() {
+                                internalCallback(subjects);
+                            });
+                        }}
+                }});
+
+            return this;
+        },
+        renderContent: function() {
+            return {content: $('<h1>Content!</h1>').html()};
+        },
+
+        show: function() {
+            if (this.dialog === null)
+                this.render();
+
+            this.dialog.trigger('show');
+
+            this.onShow();
+        },
+
+        onShow: function() {
+
+        },
+
+        hide: function() {
+            this.dialog.trigger('hide');
+            this.onHide();
+        },
+
+        onHide: function() {
+
+        },
+
+        confirm: function() {
+            if (this.confirmCallback)
+                this.confirmCallback.apply();
+
+            this.hide();
+        },
+
+        destroy: function() {
+            this.$el.remove();
+            this.dialog = null;
+            this.remove();
+        }
+
+    });
+});
\ No newline at end of file
diff --git a/module/web/static/js/views/dashboardView.js b/module/web/static/js/views/dashboardView.js
new file mode 100644
index 000000000..58a50777c
--- /dev/null
+++ b/module/web/static/js/views/dashboardView.js
@@ -0,0 +1,164 @@
+define(['jquery', 'backbone', 'underscore', 'app', 'models/TreeCollection',
+    'views/packageView', 'views/fileView', 'views/selectionView', 'views/filterView', 'select2'],
+    function($, Backbone, _, App, TreeCollection, packageView, fileView, selectionView, filterView) {
+
+        // Renders whole dashboard
+        return Backbone.View.extend({
+
+            el: '#content',
+            active: $('.breadcrumb .active'),
+
+            events: {
+            },
+
+            // <ul> holding the packages
+            packageUL: null,
+            // <ul> displaying the files
+            fileUL: null,
+            // Package tree
+            tree: null,
+            // Current open files
+            files: null,
+            // True when loading animation is running
+            isLoading: false,
+
+            initialize: function() {
+                var self = this;
+                this.tree = new TreeCollection();
+
+                var view = new selectionView();
+                view = new filterView();
+
+                // When package is added we reload the data
+                App.vent.on('package:added', function() {
+                    console.log('Package tree caught, package:added event');
+                    self.tree.fetch();
+                });
+
+                App.vent.on('file:updated', _.bind(this.fileUpdated, this));
+
+                // TODO: file:added
+                // TODO: package:deleted
+                // TODO: package:updated
+            },
+
+            init: function() {
+                var self = this;
+                // TODO: put in separated function
+                // TODO: order of elements?
+                // Init the tree and callback for package added
+                this.tree.fetch({success: function() {
+                    self.render();
+                    self.tree.get('packages').on('add', function(pack) {
+                        console.log('Package ' + pack.get('pid') + ' added to tree');
+                        self.appendPackage(pack, 0, true);
+                        self.openPackage(pack);
+                    });
+                }});
+
+                this.$('.input').select2({tags: ["a", "b", "sdf"]});
+            },
+
+            render: function() {
+                console.log('Render package list');
+                var packs = this.tree.get('packages');
+                this.files = this.tree.get('files');
+
+                this.packageUL = this.$('.package-list');
+                packs.each(_.bind(this.appendPackage, this));
+
+                this.fileUL = this.$('.file-list');
+                if (this.files.length === 0) {
+                    // no files are displayed
+                    this.files = null;
+                    // Open the first package
+                    if (packs.length >= 1)
+                        this.openPackage(packs.at(0));
+                }
+                else
+                    this.files.each(_.bind(this.appendFile, this));
+
+                return this;
+            },
+
+            // TODO sorting ?!
+            // Append a package to the list, index, animate it
+            appendPackage: function(pack, i, animation) {
+                var el = new packageView({model: pack}).render().el;
+                this.packageUL.appendWithAnimation(el, animation);
+            },
+
+            appendFile: function(file, i, animation) {
+                var el = new fileView({model: file}).render().el;
+                this.fileUL.appendWithAnimation(el, animation);
+            },
+
+            // Show content of the packages on main view
+            openPackage: function(pack) {
+                var self = this;
+
+                // load animation only when something is shown and its different from current package
+                if (this.files && this.files !== pack.get('files'))
+                    self.loading();
+
+                pack.fetch({silent: true, success: function() {
+                    console.log('Package ' + pack.get('pid') + ' loaded');
+                    self.active.text(pack.get('name'));
+                    self.contentReady(pack.get('files'));
+                }, failure: function() {
+                    self.failure();
+                }});
+
+            },
+
+            contentReady: function(files) {
+                var old_files = this.files;
+                this.files = files;
+                App.vent.trigger('dashboard:contentReady');
+
+                // show the files when no loading animation is running and not already open
+                if (!this.isLoading && old_files !== files)
+                    this.show();
+            },
+
+            // Do load animation, remove the old stuff
+            loading: function() {
+                this.isLoading = true;
+                this.files = null;
+                var self = this;
+                this.fileUL.fadeOut({complete: function() {
+                    // All file views should vanish
+                    App.vent.trigger('dashboard:destroyContent');
+
+                    // Loading was faster than animation
+                    if (self.files)
+                        self.show();
+
+                    self.isLoading = false;
+                }});
+            },
+
+            failure: function() {
+                // TODO
+            },
+
+            show: function() {
+                // fileUL has to be resetted before
+                this.files.each(_.bind(this.appendFile, this));
+                //TODO: show placeholder when nothing is displayed (filtered content empty)
+                this.fileUL.fadeIn();
+                App.vent.trigger('dashboard:updated');
+            },
+
+            // Refresh the file if it is currently shown
+            fileUpdated: function(data) {
+                // this works with ids and object
+                var file = this.files.get(data);
+                if (file)
+                    if (_.isObject(data)) // update directly
+                        file.set(data);
+                    else // fetch from server
+                        file.fetch();
+            }
+        });
+    });
\ No newline at end of file
diff --git a/module/web/static/js/views/fileView.js b/module/web/static/js/views/fileView.js
new file mode 100644
index 000000000..c673041b5
--- /dev/null
+++ b/module/web/static/js/views/fileView.js
@@ -0,0 +1,97 @@
+define(['jquery', 'backbone', 'underscore', 'app', 'utils/apitypes', 'views/abstract/itemView', 'helpers/formatTime'],
+    function($, Backbone, _, App, Api, ItemView, formatTime) {
+
+        // Renders single file item
+        return ItemView.extend({
+
+            tagName: 'li',
+            className: 'file-view row-fluid',
+            template: _.compile($("#template-file").html()),
+            events: {
+                'click .checkbox': 'select',
+                'click .btn-delete': 'deleteItem',
+                'click .btn-restart': 'restart'
+            },
+
+            initialize: function() {
+                this.listenTo(this.model, 'change', this.render);
+                // This will be triggered manually and changed before with silent=true
+                this.listenTo(this.model, 'change:visible', this.visibility_changed);
+                this.listenTo(this.model, 'change:progress', this.progress_changed);
+                this.listenTo(this.model, 'remove', this.unrender);
+                this.listenTo(App.vent, 'dashboard:destroyContent', this.destroy);
+            },
+
+            onDestroy: function() {
+            },
+
+            render: function() {
+                var data = this.model.toJSON();
+                if (data.download) {
+                    var status = data.download.status;
+                    if (status === Api.DownloadStatus.Offline || status === Api.DownloadStatus.TempOffline)
+                        data.offline = true;
+                    else if (status === Api.DownloadStatus.Online)
+                        data.online = true;
+                    else if (status === Api.DownloadStatus.Waiting)
+                        data.waiting = true;
+                    else if (status === Api.DownloadStatus.Downloading)
+                        data.downloading = true;
+                    else if (this.model.isFailed())
+                        data.failed = true;
+                    else if (this.model.isFinished())
+                        data.finished = true;
+                }
+
+                this.$el.html(this.template(data));
+                if (this.model.get('selected'))
+                    this.$el.addClass('ui-selected');
+                else
+                    this.$el.removeClass('ui-selected');
+
+                if (this.model.get('visible'))
+                    this.$el.show();
+                else
+                    this.$el.hide();
+
+                return this;
+            },
+
+            select: function(e) {
+                e.preventDefault();
+                var checked = this.$el.hasClass('ui-selected');
+                // toggle class immediately, so no re-render needed
+                this.model.set('selected', !checked, {silent: true});
+                this.$el.toggleClass('ui-selected');
+                App.vent.trigger('file:selection');
+            },
+
+            visibility_changed: function(visible) {
+                // TODO: improve animation, height is not available when element was not visible
+                if (visible)
+                    this.$el.slideOut(true);
+                else {
+                    this.$el.calculateHeight(true);
+                    this.$el.slideIn(true);
+                }
+            },
+
+            progress_changed: function() {
+                if(!this.model.isDownload())
+                    return;
+
+                if (this.model.get('download').status === Api.DownloadStatus.Downloading) {
+                    var bar = this.$('.progress .bar');
+                    if (!bar) { // ensure that the dl bar is rendered
+                        this.render();
+                        bar = this.$('.progress .bar');
+                    }
+
+                    bar.width(this.model.get('progress') + '%');
+                    bar.html('&nbsp;&nbsp;' + formatTime(this.model.get('eta')));
+                } else // Every else state can be renderred normally
+                    this.render();
+
+            }
+        });
+    });
\ No newline at end of file
diff --git a/module/web/static/js/views/filterView.js b/module/web/static/js/views/filterView.js
new file mode 100644
index 000000000..14968f2cc
--- /dev/null
+++ b/module/web/static/js/views/filterView.js
@@ -0,0 +1,133 @@
+define(['jquery', 'backbone', 'underscore', 'app', 'utils/apitypes', 'models/Package'],
+    function($, Backbone, _, App, Api, Package) {
+
+        // Modified version of type ahead show, nearly the same without absolute positioning
+        function show() {
+            this.$menu
+                .insertAfter(this.$element)
+                .show();
+
+            this.shown = true;
+            return this;
+        }
+
+        // Renders the actionbar for the dashboard, handles everything related to filtering displayed files
+        return Backbone.View.extend({
+            el: 'ul.actionbar',
+
+            events: {
+                'click .filter-type': 'filter_type',
+                'click .filter-state': 'switch_filter',
+                'submit .form-search': 'search'
+            },
+
+            state: null,
+            stateMenu: null,
+
+            initialize: function() {
+
+                // use our modified method
+                $.fn.typeahead.Constructor.prototype.show = show;
+                this.$('.search-query').typeahead({
+                    minLength: 2,
+                    source: this.getSuggestions
+                });
+
+                this.stateMenu = this.$('.dropdown-toggle .state');
+                this.state = Api.DownloadState.All;
+
+                // Apply the filter before the content is shown
+                App.vent.on('dashboard:contentReady', _.bind(this.apply_filter, this));
+            },
+
+            render: function() {
+                return this;
+            },
+
+            // TODO: app level api request
+
+            search: function(e) {
+                e.stopPropagation();
+                var input = this.$('.search-query');
+                var query = input.val();
+                input.val('');
+
+                var pack = new Package();
+                // Overwrite fetch method to use a search
+                // TODO: quite hackish, could be improved to filter packages
+                //       or show performed search
+                pack.fetch = function(options) {
+                    pack.search(query, options);
+                };
+
+                App.dashboard.openPackage(pack);
+            },
+
+            getSuggestions: function(query, callback) {
+                $.ajax('/api/searchSuggestions', {
+                    method: 'POST',
+                    data: {pattern: JSON.stringify(query)},
+                    success: function(data) {
+                        callback(data);
+                    }
+                });
+            },
+
+            switch_filter: function(e) {
+                e.stopPropagation();
+                var element = $(e.target);
+                var state = parseInt(element.data('state'), 10);
+                var menu = this.stateMenu.parent().parent();
+                menu.removeClass('open');
+
+                if (state === Api.DownloadState.Finished) {
+                    menu.removeClass().addClass('dropdown finished');
+                } else if (state === Api.DownloadState.Unfinished) {
+                    menu.removeClass().addClass('dropdown active');
+                } else if (state === Api.DownloadState.Failed) {
+                    menu.removeClass().addClass('dropdown failed');
+                } else {
+                    menu.removeClass().addClass('dropdown');
+                }
+
+                this.state = state;
+                this.stateMenu.text(element.text());
+                this.apply_filter();
+            },
+
+            // Applies the filtering to current open files
+            apply_filter: function() {
+                if (!App.dashboard.files)
+                    return;
+
+                var self = this;
+                App.dashboard.files.map(function(file) {
+                    var visible = file.get('visible');
+                    if (visible !== self.is_visible(file)) {
+                        file.set('visible', !visible, {silent: true});
+                        file.trigger('change:visible', !visible);
+                    }
+                });
+
+                App.vent.trigger('dashboard:filtered');
+            },
+
+            // determine if a file should be visible
+            // TODO: non download files
+            is_visible: function(file) {
+                if (this.state === Api.DownloadState.Finished)
+                    return file.isFinished();
+                else if (this.state === Api.DownloadState.Unfinished)
+                    return file.isUnfinished();
+                else if (this.state === Api.DownloadState.Failed)
+                    return file.isFailed();
+
+                return true;
+            },
+
+            filter_type: function(e) {
+
+            }
+
+        });
+    });
\ No newline at end of file
diff --git a/module/web/static/js/views/headerView.js b/module/web/static/js/views/headerView.js
new file mode 100644
index 000000000..25127a337
--- /dev/null
+++ b/module/web/static/js/views/headerView.js
@@ -0,0 +1,231 @@
+define(['jquery', 'underscore', 'backbone', 'app', 'models/ServerStatus', 'collections/ProgressList',
+    'views/progressView', 'views/notificationView', 'helpers/formatSize', 'flot'],
+    function($, _, Backbone, App, ServerStatus, ProgressList, ProgressView, notificationView, formatSize) {
+        // Renders the header with all information
+        return Backbone.View.extend({
+
+            el: 'header',
+
+            events: {
+                'click .iconf-list': 'toggle_taskList',
+                'click .popover .close': 'toggle_taskList',
+                'click .btn-grabber': 'open_grabber'
+            },
+
+            // todo: maybe combine these
+            templateStatus: _.compile($('#template-header-status').html()),
+            templateHeader: _.compile($('#template-header').html()),
+
+            // html elements
+            grabber: null,
+            header: null,
+            progress: null,
+            speedgraph: null,
+
+            // models and data
+            ws: null,
+            status: null,
+            progressList: null,
+            speeds: null,
+
+            // sub view
+            notificationView: null,
+
+            // save if last progress was empty
+            wasEmpty: false,
+
+            initialize: function() {
+                var self = this;
+                this.notificationView = new notificationView();
+
+                this.status = new ServerStatus();
+                this.listenTo(this.status, 'change', this.render);
+
+                this.progress = this.$('.progress-list');
+                this.progressList = new ProgressList();
+                this.listenTo(this.progressList, 'add', function(model) {
+                    self.progress.appendWithAnimation(new ProgressView({model: model}).render().el);
+                });
+
+                // TODO: button to start stop refresh
+                var ws = App.openWebSocket('/async');
+                ws.onopen = function() {
+                    ws.send(JSON.stringify('start'));
+                };
+                // TODO compare with polling
+                ws.onmessage = _.bind(this.onData, this);
+                ws.onerror = function(error) {
+                    alert(error);
+                };
+
+                this.ws = ws;
+
+                this.initGraph();
+            },
+
+            initGraph: function() {
+                var totalPoints = 120;
+                var data = [];
+
+                // init with empty data
+                while (data.length < totalPoints)
+                    data.push([data.length, 0]);
+
+                this.speeds = data;
+                this.speedgraph = $.plot(this.$el.find("#speedgraph"), [this.speeds], {
+                    series: {
+                        lines: { show: true, lineWidth: 2 },
+                        shadowSize: 0,
+                        color: "#fee247"
+                    },
+                    xaxis: { ticks: [] },
+                    yaxis: { ticks: [], min: 1, autoscaleMargin: 0.1, tickFormatter: function(data) {
+                        return formatSize(data * 1024);
+                    }, position: "right" },
+                    grid: {
+                        show: true,
+//            borderColor: "#757575",
+                        borderColor: "white",
+                        borderWidth: 1,
+                        labelMargin: 0,
+                        axisMargin: 0,
+                        minBorderMargin: 0
+                    }
+                });
+
+            },
+
+            render: function() {
+                // TODO: what should be displayed in the header
+                // queue/processing size?
+
+                var status = this.status.toJSON();
+                status.maxspeed = _.max(this.speeds, function(speed) {
+                    return speed[1];
+                })[1] * 1024;
+                this.$('.status-block').html(
+                    this.templateStatus(status)
+                );
+
+                var data = {tasks: 0, downloads: 0, speed: 0, single: false};
+                this.progressList.each(function(progress) {
+                    if (progress.isDownload()) {
+                        data.downloads += 1;
+                        data.speed += progress.get('download').speed;
+                    } else
+                        data.tasks++;
+                });
+
+                // Show progress of one task
+                if (data.tasks + data.downloads === 1) {
+                    var progress = this.progressList.at(0);
+                    data.single = true;
+                    data.eta = progress.get('eta');
+                    data.percent = progress.getPercent();
+                    data.name = progress.get('name');
+                    data.statusmsg = progress.get('statusmsg');
+                }
+                // TODO: better progressbar rendering
+
+                data.etaqueue = status.eta;
+                data.linksqueue = status.linksqueue;
+                data.sizequeue = status.sizequeue;
+
+                this.$('#progress-info').html(
+                    this.templateHeader(data)
+                );
+                return this;
+            },
+
+            toggle_taskList: function() {
+                this.$('.popover').animate({opacity: 'toggle'});
+            },
+
+            open_grabber: function() {
+                var self = this;
+                _.requireOnce(['views/linkGrabberModal'], function(modalView) {
+                    if (self.grabber === null)
+                        self.grabber = new modalView();
+
+                    self.grabber.show();
+                });
+            },
+
+            onData: function(evt) {
+                var data = JSON.parse(evt.data);
+                if (data === null) return;
+
+                if (data['@class'] === "ServerStatus") {
+                    // TODO: load interaction when none available
+                    this.status.set(data);
+
+                    // There tasks at the server, but not in queue: so fetch them
+                    // or there are tasks in our queue but not on the server
+                    if (this.status.get('notifications') && !this.notificationView.tasks.hasTaskWaiting() ||
+                        !this.status.get('notifications') && this.notificationView.tasks.hasTaskWaiting())
+                        this.notificationView.tasks.fetch();
+
+                    this.speeds = this.speeds.slice(1);
+                    this.speeds.push([this.speeds[this.speeds.length - 1][0] + 1, Math.floor(data.speed / 1024)]);
+
+                    // TODO: if everything is 0 rerender is not needed
+                    this.speedgraph.setData([this.speeds]);
+                    // adjust the axis
+                    this.speedgraph.setupGrid();
+                    this.speedgraph.draw();
+
+                }
+                else if (_.isArray(data))
+                    this.onProgressUpdate(data);
+                else if (data['@class'] === 'EventInfo')
+                    this.onEvent(data.eventname, data.event_args);
+                else
+                    console.log('Unknown Async input', data);
+
+            },
+
+            onProgressUpdate: function(progress) {
+                // generate a unique id
+                _.each(progress, function(prog) {
+                    if (prog.download)
+                        prog.pid = prog.download.fid;
+                    else
+                        prog.pid = prog.plugin + prog.name;
+                });
+
+                this.progressList.update(progress);
+                // update currently open files with progress
+                this.progressList.each(function(prog) {
+                    if (prog.isDownload() && App.dashboard.files) {
+                        var file = App.dashboard.files.get(prog.get('download').fid);
+                        if (file) {
+                            file.set({
+                                progress: prog.getPercent(),
+                                eta: prog.get('eta'),
+                            }, {silent: true});
+
+                            file.trigger('change:progress');
+                        }
+                    }
+                });
+
+                if (progress.length === 0) {
+                    // only render one time when last was not empty already
+                    if (!this.wasEmpty) {
+                        this.render();
+                        this.wasEmpty = true;
+                    }
+                } else {
+                    this.wasEmpty = false;
+                    this.render();
+                }
+            },
+
+            onEvent: function(event, args) {
+                args.unshift(event);
+                console.log('Core send event', args);
+                App.vent.trigger.apply(App.vent, args);
+            }
+
+        });
+    });
\ No newline at end of file
diff --git a/module/web/static/js/views/linkGrabberModal.js b/module/web/static/js/views/linkGrabberModal.js
new file mode 100644
index 000000000..e2b6e985d
--- /dev/null
+++ b/module/web/static/js/views/linkGrabberModal.js
@@ -0,0 +1,48 @@
+define(['jquery', 'underscore', 'app', 'views/abstract/modalView', 'text!tpl/default/linkgrabber.html'],
+    function($, _, App, modalView, template) {
+        // Modal dialog for package adding - triggers package:added when package was added
+        return modalView.extend({
+
+            events: {
+                'click .btn-success': 'addPackage',
+                'keypress #inputPackageName': 'addOnEnter'
+            },
+
+            template: _.compile(template),
+
+            initialize: function() {
+                // Inherit parent events
+                this.events = _.extend({}, modalView.prototype.events, this.events);
+            },
+
+            addOnEnter: function(e) {
+                if (e.keyCode != 13) return;
+                this.addPackage(e);
+            },
+
+            addPackage: function(e) {
+                var self = this;
+                var options = App.apiRequest('addPackage',
+                    {
+                        name: $('#inputPackageName').val(),
+                        // TODO: better parsing / tokenization
+                        links: $('#inputLinks').val().split("\n")
+                    },
+                    {
+                        success: function() {
+                            App.vent.trigger('package:added');
+                            self.hide();
+                        }
+                    });
+
+                $.ajax(options);
+                $('#inputPackageName').val('');
+                $('#inputLinks').val('');
+            },
+
+            onShow: function() {
+                this.$('#inputPackageName').focus();
+            }
+
+        });
+    });
\ No newline at end of file
diff --git a/module/web/static/js/views/notificationView.js b/module/web/static/js/views/notificationView.js
new file mode 100644
index 000000000..afb542eed
--- /dev/null
+++ b/module/web/static/js/views/notificationView.js
@@ -0,0 +1,80 @@
+define(['jquery', 'backbone', 'underscore', 'app', 'collections/InteractionList'],
+    function($, Backbone, _, App, InteractionList, queryModal) {
+
+        // Renders context actions for selection packages and files
+        return Backbone.View.extend({
+            el: '#notification-area',
+            template: _.compile($("#template-notification").html()),
+
+            events: {
+                'click .btn-query': 'openQuery',
+                'click .btn-notification': 'openNotifications'
+            },
+
+            tasks: null,
+            // area is slided out
+            visible: false,
+            // the dialog
+            modal: null,
+
+            initialize: function() {
+                this.tasks = new InteractionList();
+
+                this.$el.calculateHeight().height(0);
+
+                App.vent.on('interaction:added', _.bind(this.onAdd, this));
+                App.vent.on('interaction:deleted', _.bind(this.onDelete, this));
+
+                var render = _.bind(this.render, this);
+                this.listenTo(this.tasks, 'add', render);
+                this.listenTo(this.tasks, 'remove', render);
+
+            },
+
+            onAdd: function(task) {
+                this.tasks.add(task);
+            },
+
+            onDelete: function(task) {
+                this.tasks.remove(task);
+            },
+
+            render: function() {
+
+                // only render when it will be visible
+                if (this.tasks.length > 0)
+                    this.$el.html(this.template(this.tasks.toJSON()));
+
+                if (this.tasks.length > 0 && !this.visible) {
+                    this.$el.slideOut();
+                    this.visible = true;
+                }
+                else if (this.tasks.length === 0 && this.visible) {
+                    this.$el.slideIn();
+                    this.visible = false;
+                }
+
+                return this;
+            },
+
+            openQuery: function() {
+                var self = this;
+
+                _.requireOnce(['views/queryModal'], function(modalView) {
+                    if (self.modal === null) {
+                        self.modal = new modalView();
+                        self.modal.parent = self;
+                    }
+
+                    self.modal.model = self.tasks.at(0);
+                    self.modal.render();
+                    self.modal.show();
+                });
+
+            },
+
+            openNotifications: function() {
+
+            }
+        });
+    });
\ No newline at end of file
diff --git a/module/web/static/js/views/packageView.js b/module/web/static/js/views/packageView.js
new file mode 100644
index 000000000..547c1470d
--- /dev/null
+++ b/module/web/static/js/views/packageView.js
@@ -0,0 +1,74 @@
+define(['jquery', 'app', 'views/abstract/itemView', 'underscore'],
+    function($, App, itemView, _) {
+
+        // Renders a single package item
+        return itemView.extend({
+
+            tagName: 'li',
+            className: 'package-view',
+            template: _.compile($("#template-package").html()),
+            events: {
+                'click .package-name, .btn-open': 'open',
+                'click .iconf-refresh': 'restart',
+                'click .select': 'select',
+                'click .btn-delete': 'deleteItem'
+            },
+
+            // Ul for child packages (unused)
+            ul: null,
+            // Currently unused
+            expanded: false,
+
+            initialize: function() {
+                this.listenTo(this.model, 'filter:added', this.hide);
+                this.listenTo(this.model, 'filter:removed', this.show);
+                this.listenTo(this.model, 'change', this.render);
+                this.listenTo(this.model, 'remove', this.unrender);
+
+                // Clear drop down menu
+                var self = this;
+                this.$el.on('mouseleave', function() {
+                    self.$('.dropdown-menu').parent().removeClass('open');
+                });
+            },
+
+            onDestroy: function() {
+            },
+
+            // Render everything, optional only the fileViews
+            render: function() {
+                this.$el.html(this.template(this.model.toJSON()));
+                this.$el.initTooltips();
+
+                return this;
+            },
+
+            unrender: function() {
+                itemView.prototype.unrender.apply(this);
+
+                // TODO: display other package
+                App.vent.trigger('dashboard:loading', null);
+            },
+
+
+            // TODO
+            // Toggle expanding of packages
+            expand: function(e) {
+                e.preventDefault();
+            },
+
+            open: function(e) {
+                e.preventDefault();
+                App.dashboard.openPackage(this.model);
+            },
+
+            select: function(e) {
+                e.preventDefault();
+                var checked = this.$('.select').hasClass('iconf-check');
+                // toggle class immediately, so no re-render needed
+                this.model.set('selected', !checked, {silent: true});
+                this.$('.select').toggleClass('iconf-check').toggleClass('iconf-check-empty');
+                App.vent.trigger('package:selection');
+            }
+        });
+    });
\ No newline at end of file
diff --git a/module/web/static/js/views/progressView.js b/module/web/static/js/views/progressView.js
new file mode 100644
index 000000000..3c2908000
--- /dev/null
+++ b/module/web/static/js/views/progressView.js
@@ -0,0 +1,31 @@
+define(['jquery', 'backbone', 'underscore', 'app', 'utils/apitypes', 'views/abstract/itemView'],
+    function($, Backbone, _, App, Api, ItemView) {
+
+        // Renders single file item
+        return ItemView.extend({
+
+            idAttribute: 'pid',
+            tagName: 'li',
+            template: _.compile($("#template-header-progress").html()),
+            events: {
+            },
+
+            initialize: function() {
+                this.listenTo(this.model, 'change', this.render);
+                this.listenTo(this.model, 'remove', this.unrender);
+            },
+
+            onDestroy: function() {
+            },
+
+            render: function() {
+                // TODO: icon
+                // TODO: other states
+                // TODO: non download progress
+                // TODO: better progressbar rendering
+                this.$el.css('background-image', 'url(icons/sdf)');
+                this.$el.html(this.template(this.model.toJSON()));
+                return this;
+            }
+        });
+    });
\ No newline at end of file
diff --git a/module/web/static/js/views/queryModal.js b/module/web/static/js/views/queryModal.js
new file mode 100644
index 000000000..5d1585a0d
--- /dev/null
+++ b/module/web/static/js/views/queryModal.js
@@ -0,0 +1,54 @@
+define(['jquery', 'underscore', 'app', 'views/abstract/modalView', 'text!tpl/default/queryDialog.html'],
+    function($, _, App, modalView, template) {
+        return modalView.extend({
+
+            events: {
+                'click .btn-success': 'submit',
+                'submit form': 'submit'
+            },
+
+            model: null,
+            parent: null,
+            template: _.compile(template),
+
+            initialize: function() {
+                // Inherit parent events
+                this.events = _.extend({}, modalView.prototype.events, this.events);
+            },
+
+            renderContent: function() {
+                var data = {
+                    title: this.model.get('title'),
+                    plugin: this.model.get('plugin'),
+                    description: this.model.get('description')
+                };
+
+                if (this.model.isCaptcha()) {
+                    var input = this.model.get('input').data;
+                    data.captcha = input[0];
+                    data.type = input[1];
+                }
+
+                return data;
+            },
+
+            submit: function(e) {
+                e.stopPropagation();
+                // TODO: different input types
+                // TODO: load next task
+
+                this.model.set('result', this.$('input').val());
+                var self = this;
+                this.model.save({success: function() {
+                    self.hide();
+                }});
+
+                this.$('input').val('');
+            },
+
+            onShow: function() {
+                this.$('input').focus();
+            }
+
+        });
+    });
\ No newline at end of file
diff --git a/module/web/static/js/views/selectionView.js b/module/web/static/js/views/selectionView.js
new file mode 100644
index 000000000..546cda847
--- /dev/null
+++ b/module/web/static/js/views/selectionView.js
@@ -0,0 +1,150 @@
+define(['jquery', 'backbone', 'underscore', 'app'],
+    function($, Backbone, _, App) {
+
+        // Renders context actions for selection packages and files
+        return Backbone.View.extend({
+            el: '#selection-area',
+            template: _.compile($("#template-select").html()),
+
+            events: {
+                'click .iconf-check': 'deselect',
+                'click .iconf-pause': 'pause',
+                'click .iconf-trash': 'trash',
+                'click .iconf-refresh': 'restart'
+            },
+
+            // Element of the action bar
+            actionBar: null,
+            // number of currently selected elements
+            current: 0,
+
+            initialize: function() {
+                this.$el.calculateHeight().height(0);
+
+                var render = _.bind(this.render, this);
+
+                App.vent.on('dashboard:updated', render);
+                App.vent.on('dashboard:filtered', render);
+                App.vent.on('package:selection', render);
+                App.vent.on('file:selection', render);
+
+                this.actionBar = $('.actionbar .btn-check');
+                this.actionBar.parent().click(_.bind(this.select_toggle, this));
+
+                // API events, maybe better to rely on internal ones?
+                App.vent.on('package:deleted', render);
+                App.vent.on('file:deleted', render);
+            },
+
+            get_files: function(all) {
+                var files = [];
+                if (App.dashboard.files)
+                    if (all)
+                        files = App.dashboard.files.where({visible: true});
+                    else
+                        files = App.dashboard.files.where({selected: true, visible: true});
+
+                return files;
+            },
+
+            get_packs: function() {
+                return App.dashboard.tree.get('packages').where({selected: true});
+            },
+
+            render: function() {
+                var files = this.get_files().length;
+                var packs = this.get_packs().length;
+
+                if (files + packs > 0) {
+                    this.$el.html(this.template({files: files, packs: packs}));
+                    this.$el.initTooltips('bottom');
+                }
+
+                if (files + packs > 0 && this.current === 0)
+                    this.$el.slideOut();
+                else if (files + packs === 0 && this.current > 0)
+                    this.$el.slideIn();
+
+                if (files > 0) {
+                    this.actionBar.addClass('iconf-check').removeClass('iconf-check-empty');
+                    App.dashboard.packageUL.addClass('ui-files-selected');
+                }
+                else {
+                    this.actionBar.addClass('iconf-check-empty').removeClass('iconf-check');
+                    App.dashboard.packageUL.removeClass('ui-files-selected');
+                }
+
+                this.current = files + packs;
+            },
+
+            // Deselects all items
+            deselect: function() {
+                this.get_files().map(function(file) {
+                    file.set('selected', false);
+                });
+
+                this.get_packs().map(function(pack) {
+                    pack.set('selected', false);
+                });
+
+                this.render();
+            },
+
+            pause: function() {
+                alert("Not implemented yet");
+                this.deselect();
+            },
+
+            trash: function() {
+                _.confirm('default/confirmDialog.html', function() {
+
+                    var pids = [];
+                    // TODO: delete many at once
+                    this.get_packs().map(function(pack) {
+                        pids.push(pack.get('pid'));
+                        pack.destroy();
+                    });
+
+                    // get only the fids of non deleted packages
+                    var fids = _.filter(this.get_files(),function(file) {
+                        return !_.contains(pids, file.get('package'));
+                    }).map(function(file) {
+                            file.destroyLocal();
+                            return file.get('fid');
+                        });
+
+                    if (fids.length > 0)
+                        $.ajax(App.apiRequest('deleteFiles', {fids: fids}));
+
+                    this.deselect();
+                }, this);
+            },
+
+            restart: function() {
+                this.get_files().map(function(file) {
+                    file.restart();
+                });
+                this.get_packs().map(function(pack) {
+                    pack.restart();
+                });
+
+                this.deselect();
+            },
+
+            // Select or deselect all visible files
+            select_toggle: function() {
+                var files = this.get_files();
+                if (files.length === 0) {
+                    this.get_files(true).map(function(file) {
+                        file.set('selected', true);
+                    });
+
+                } else
+                    files.map(function(file) {
+                        file.set('selected', false);
+                    });
+
+                this.render();
+            }
+        });
+    });
\ No newline at end of file
diff --git a/module/web/static/js/views/settingsView.js b/module/web/static/js/views/settingsView.js
new file mode 100644
index 000000000..a322cdae7
--- /dev/null
+++ b/module/web/static/js/views/settingsView.js
@@ -0,0 +1,56 @@
+define(['jquery', 'underscore', 'backbone'],
+    function($, _, Backbone) {
+
+        // Renders settings over view page
+        return Backbone.View.extend({
+
+            el: "#content",
+            template_menu: _.compile($("#template-menu").html()),
+
+            events: {
+                'click .settings-menu li > a': 'change_section'
+            },
+
+            menu: null,
+
+            core_config: null, // It seems models are not needed
+            plugin_config: null,
+
+            initialize: function() {
+                this.menu = $('.settings-menu');
+                this.refresh();
+
+                console.log("Settings initialized");
+            },
+
+            refresh: function() {
+                var self = this;
+                $.ajax("/api/getCoreConfig", {success: function(data) {
+                    self.core_config = data;
+                    self.render()
+                }});
+                $.ajax("/api/getPluginConfig", {success: function(data) {
+                    self.plugin_config = data;
+                    self.render();
+                }});
+            },
+
+            render: function() {
+                this.menu.html(this.template_menu({
+                        core: this.core_config,
+                        plugin: this.plugin_config
+                    }));
+            },
+
+            change_section: function(e) {
+                var el = $(e.target).parent();
+                var name = el.data("name");
+                console.log("Section changed to " + name);
+
+                this.menu.find("li.active").removeClass("active");
+                el.addClass("active");
+                e.preventDefault();
+            }
+
+        });
+    });
\ No newline at end of file
diff --git a/module/web/templates/500.html b/module/web/templates/500.html
index e15090b66..8bffe6dbb 100644
--- a/module/web/templates/500.html
+++ b/module/web/templates/500.html
@@ -1,5 +1,4 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
-        "http://www.w3.org/TR/html4/loose.dtd">
+<!doctype html>
 <html>
 <head>
     <title>Server Error</title>
diff --git a/module/web/templates/default/admin.html b/module/web/templates/default/admin.html
index b049411fd..9bbcc2104 100644
--- a/module/web/templates/default/admin.html
+++ b/module/web/templates/default/admin.html
@@ -1,98 +1,223 @@
-{% extends 'default/base.html' %}
-
-{% block head %}
-    <script type="text/javascript" src="media/js/admin.js"></script>
-{% endblock %}
-
-
-{% block title %}{{ _("Administrate") }} - {{ super() }} {% endblock %}
-{% block subtitle %}{{ _("Administrate") }}{% endblock %}
-
-{% block content %}
-    
-    <a href="#" id="quit-pyload" style="font-size: large; font-weight: bold;">{{_("Quit pyLoad")}}</a> |
-    <a href="#" id="restart-pyload" style="font-size: large; font-weight: bold;">{{_("Restart pyLoad")}}</a>
-    <br>
-    <br>
-
-    {{ _("To add user or change passwords use:") }} <b>python pyLoadCore.py -u</b><br>
-    {{ _("Important: Admin user have always all permissions!") }}
-
-    <form action="" method="POST">
-        <table class="settable wide">
-            <thead style="font-size: 11px">
-            <th>
-                {{ _("Name") }}
-            </th>
-            <th>
-                {{ _("Change Password") }}
-            </th>
-            <th>
-                {{ _("Admin") }}
-            </th>
-            <th>
-                {{ _("Permissions") }}
-            </th>
-            </thead>
-
-            {% for name, data in users.iteritems() %}
-                <tr>
-                    <td>{{ name }}</td>
-                    <td><a class="change_password" href="#" id="change_pw|{{name}}">{{ _("change") }}</a></td>
-                    <td><input name="{{ name }}|admin" type="checkbox" {% if data.perms.admin %}
-                               checked="True" {% endif %}"></td>
-                    <td>
-                        <select multiple="multiple" size="{{ permlist|length }}" name="{{ name }}|perms">
-                            {% for perm in permlist %}
-                            {% if data.perms|getitem(perm) %}
-                                <option selected="selected">{{ perm }}</option>
-                            {% else %}
-                                <option>{{ perm }}</option>
-                            {% endif %}
-                            {% endfor %}
-                        </select>
-                    </td>
-                </tr>
-            {% endfor %}
-
-
-        </table>
-
-        <button class="styled_button" type="submit">{{ _("Submit") }}</button>
-    </form>
-{% endblock %}
-{% block hidden %}
-    <div id="password_box" class="window_box" style="z-index: 2">
-        <form id="password_form" action="/json/change_password" method="POST" enctype="multipart/form-data">
-            <h1>{{ _("Change Password") }}</h1>
-
-            <p>{{ _("Enter your current and desired Password.") }}</p>
-            <label for="user_login">{{ _("User") }}
-                <span class="small">{{ _("Your username.") }}</span>
-            </label>
-            <input id="user_login" name="user_login" type="text" size="20"/>
-
-            <label for="login_current_password">{{ _("Current password") }}
-                <span class="small">{{ _("The password for this account.") }}</span>
-            </label>
-            <input id="login_current_password" name="login_current_password" type="password" size="20"/>
-
-            <label for="login_new_password">{{ _("New password") }}
-                <span class="small">{{ _("The new password.") }}</span>
-            </label>
-            <input id="login_new_password" name="login_new_password" type="password" size="20"/>
-
-            <label for="login_new_password2">{{ _("New password (repeat)") }}
-                <span class="small">{{ _("Please repeat the new password.") }}</span>
-            </label>
-            <input id="login_new_password2" name="login_new_password2" type="password" size="20"/>
-
-
-            <button id="login_password_button" type="submit">{{ _("Submit") }}</button>
-            <button id="login_password_reset" style="margin-left: 0" type="reset">{{ _("Reset") }}</button>
-            <div class="spacer"></div>
-
-        </form>
-
-    </div>
-{% endblock %}
+{% extends 'default/base.html' %}

+

+{% block title %}{{ _("Admin") }} - {{ super() }} {% endblock %}

+{% block subtitle %}{{ _("Admin") }}

+{% endblock %}

+

+{% block css %}

+    <link href="static/css/default/admin.less" rel="stylesheet/less" type="text/css" media="screen"/>

+    <link rel="stylesheet" type="text/css" href="static/css/fontawesome.css" />

+{% endblock %}

+

+{% block require %}

+{% endblock %}

+

+{% block content %}

+    <div class="container-fluid">

+      <div class="row-fluid">

+        <div id="userlist" class="span10">

+            <div class="page-header">

+                <h1>Admin Bereich

+                <small>Userverwaltung, Systeminfos</small>

+                    <a id="btn_newuser" class="btn btn-warning btn-large" type="button"><i class="iconf-plus-sign iconf-large "></i></a>

+                </h1>

+                

+

+                

+            </div>

+

+            <div class="dropdown">        

+                <span class="label name">User</span>

+                <a class="dropdown-toggle" data-toggle="dropdown" href="#"><i class="iconf-user iconf-8x"></i></a>

+                <ul class="dropdown-menu" role="menu" aria-labelledby="dropdownMenu">

+                    <li><a tabindex="-1" id="useredit" href="#" role="button" data-backdrop="true" data-controls-modal="event-modal" data-keyboard="true"><i class="icon-pencil"></i>Edit</a></li>

+                    <li><a tabindex="-1" href="#"><i class="icon-tasks"></i>Statistik</a></li>

+                    <li class="divider"></li>

+                    <li><a tabindex="-1" href="#"><i class="icon-remove-sign"></i>Delete</a></li>

+                </ul>

+            </div>

+

+            <div id="event-modal" class="modal hide fade">

+                <div class="modal-header">

+                    <a class="close" id="useredit_close" href="#">x</a>

+                    <h3>User Settings</h3>

+                </div>

+                <div class="modal-body">

+                    <p>Set password and permissions</p>

+                    <table style="width:100%;" class="table ">

+                        <td>

+                            <div class="input-prepend">

+                                <span class="add-on"><i class="iconf-key"></i></span>

+                                <input class="span2" style="min-width:120px;" id="prependedInput" type="text" placeholder="New Password">

+                            </div>

+                            <div class="input-prepend">

+                                <span class="add-on"><i class="icon-repeat"></i></span>

+                                <input class="span2" style="min-width:120px;" id="prependedInput" type="text" placeholder="Repeat">

+                            </div>

+                            <br>

+                            <br>

+                            <br>

+                            <form class="form-horizontal">

+                                <div class="control-group">

+                                    <label class="control-label" for="onoff">Administrator</label>

+

+                                    <div class="controls">

+                                        <div class="btn-group" id="onoff" data-toggle="buttons-radio">

+                                            <button type="button" class="btn btn-primary" >On</button>

+                                            <button type="button" class="btn btn-primary active">Off</button>

+                                        </div>

+                                    </div>

+                                </div>

+                            </form>

+                        </td>

+                        <td>

+                            <div id="user_permissions">

+                                <h3>Permissions</h3>

+                                <div class="btn-group btn-group-vertical" data-toggle="buttons-checkbox">

+                                    <button type="button" class="btn btn-inverse userperm">Accounts</button>

+                                    <button type="button" class="btn btn-inverse userperm active">Add</button>

+                                    <button type="button" class="btn btn-inverse userperm">Delete</button>

+                                    <button type="button" class="btn btn-inverse userperm active">Download</button>

+                                    <button type="button" class="btn btn-inverse userperm active">List</button>

+                                    <button type="button" class="btn btn-inverse userperm">Logs</button>

+                                    <button type="button" class="btn btn-inverse userperm">Modify</button>

+                                    <button type="button" class="btn btn-inverse userperm">Settings</button>

+                                    <button type="button" class="btn btn-inverse userperm active">Status</button>

+                                </div>

+                            </div>

+                        </td>

+                    </table>

+                </div>

+                <div class="modal-footer">

+                    <a class="btn btn-primary" id="useredit_save"href="#">Save</a>

+                    

+                </div>

+            </div>

+

+

+    

+        </div>

+

+        <div class="span2">

+            <br>

+            <h2>Support</h2>

+            <table>

+                <tr>

+                    <td>

+                        <i class="icon-globe"></i>

+                    </td>

+                    <td>

+                        <a href="#">Wiki |</a>

+                        <a href="#">Forum |</a>

+                        <a href="#">Chat</a>

+                    </td>

+                </tr>

+                <tr>

+                    <td>

+                        <i class="icon-book"></i>

+                    </td>

+                    <td>

+                        <a href="#">Documentation</a>

+                    </td>

+                </tr>

+                <tr>

+                    <td>

+                        <i class="icon-fire"></i>

+                    </td>

+                    <td>

+                        <a href="#">Development</a>

+                    </td>

+                </tr>

+                <tr>

+                    <td>

+                        <i class="icon-bullhorn"></i>

+                    </td>

+                    <td>

+                        <a href="#">Issue Tracker</a>

+                    </td>

+                </tr>

+            </table>

+            <br>

+            <a href="#" class="btn btn-inverse" id="info" rel="popover"  data-content="<table class='table table-striped'>

+                <tbody>

+                    <tr>

+                        <td>Python:</td>

+                        <td>2.6.4 </td>

+                    </tr>

+                    <tr>

+                        <td>Betriebssystem:</td>

+                        <td>nt win32</td>

+                    </tr>

+                    <tr>

+                        <td>pyLoad Version:</td>

+                        <td>0.4.9</td>

+                    </tr>

+                    <tr>

+                        <td>Installationsordner:</td>

+                        <td>C:\pyLoad</td>

+                    </tr>

+                    <tr>

+                        <td>Konfigurationsordner:</td>

+                        <td>C:\Users\Marvin\pyload</td>

+                    </tr>

+                    <tr>

+                        <td>Downloadordner:</td>

+                        <td>C:\Users\Marvin\new</td>

+                    </tr>

+                    <tr>

+                        <td>HDD:</td>

+                        <td>1.67 TiB <div class='progress progress-striped active'>

+  <div class='bar' style='width: 40%;'></div>

+</div></td>

+                    </tr>

+                    <tr>

+                        <td>Sprache:</td>

+                        <td>de</td>

+                    </tr>

+                    <tr>

+                        <td>Webinterface Port:</td>

+                        <td>8000</td>

+                    </tr>

+                    <tr>

+                        <td>Remote Interface Port:</td>

+                        <td>7227</td>

+                    </tr>

+                </tbody>

+            </table>" title="Systeminformationen">System</a>

+            

+        </div>

+      </div>

+    </div>

+   

+    <script src="static/js/libs/jquery-1.9.0.js"></script>

+    {##}

+    <script src="static/js/libs/bootstrap-2.2.2.js"></script>

+    <script type="text/javascript">

+        $('#info').popover({

+            placement: 'left',

+            trigger: 'click',

+            html:'true',

+        });

+        

+            $('.dropdown-toggle').dropdown();

+

+            $("#btn_newuser").click(function() {

+                 

+                 str = "<div class='dropdown1'><span class='label name'>User</span><a class='dropdown-toggle' data-toggle='dropdown1' href='#'><i class='iconf-user iconf-8x'></i></a><ul class='dropdown-menu' role='menu' aria-labelledby='dropdownMenu'><li><a tabindex='-1' href='#'>Action</a></li><li><a tabindex='-1' href='#'>Another action</a></li><li><a tabindex='-1' href='#'>Something else here</a></li><li class='divider'></li><li><a tabindex='-1' href='#'>Separated link</a></li></ul></div>";

+

+            $("#userlist").append(str);

+

+            });

+

+            $("#useredit").click(function() {

+                $('#event-modal').modal();

+            });

+            $("#useredit_close").click(function() {

+                $('#event-modal').modal('hide');

+            });

+            $("#useredit_save").click(function() {

+                $('#event-modal').modal('hide');

+            });

+

+    </script>

+{% endblock %} 
\ No newline at end of file
diff --git a/module/web/templates/default/backbone/confirmDialog.html b/module/web/templates/default/backbone/confirmDialog.html
new file mode 100644
index 000000000..cf30f5f8e
--- /dev/null
+++ b/module/web/templates/default/backbone/confirmDialog.html
@@ -0,0 +1,11 @@
+{% extends 'default/backbone/modal.html' %}
+{% block header %}
+    Please confirm
+{% endblock %}
+{% block content %}
+    Do you want to delete the selected items?
+{% endblock %}
+{% block buttons %}
+    <a href="#" class="btn btn-danger btn-confirm"><i class="icon-trash icon-white"></i> Delete</a>
+    <a href="#" class="btn btn-close">Cancel</a>
+{% endblock %}
\ No newline at end of file
diff --git a/module/web/templates/default/backbone/linkgrabber.html b/module/web/templates/default/backbone/linkgrabber.html
new file mode 100755
index 000000000..4bedd922c
--- /dev/null
+++ b/module/web/templates/default/backbone/linkgrabber.html
@@ -0,0 +1,46 @@
+{% extends 'default/backbone/modal.html' %}

+{% block header %}

+    AddPackage

+    <small>paste&add links to pyLoad</small>

+{% endblock %}

+{% block content %}

+    <div class="alert alert-error hidden">

+        Upload files container failed. Please try again.

+    </div>

+    <form class="form-horizontal">

+        <div class="control-group">

+            <label class="control-label" for="inputPackageName">Package name</label>

+

+            <div class="controls">

+                <input type="text" class="span4" id="inputPackageName" placeholder="Name of your package">

+            </div>

+        </div>

+        <div class="control-group">

+            <label class="control-label" for="inputLinks">Links</label>

+

+            <div class="controls">

+                <textarea id="inputLinks" class="span4" rows="10" placeholder="Paste your links here..."></textarea>

+            </div>

+        </div>

+        <div class="control-group">

+            <label class="control-label" for="inputPassword">Password</label>

+

+            <div class="controls">

+                <input type="text" id="inputPassword" class="span4" placeholder="Password for .rar files">

+            </div>

+        </div>

+        <div class="control-group">

+            <label class="control-label" for="inputContainer">Upload links container</label>

+

+            <div class="controls controls-row">

+                <input type="text" id="inputContainer" class="span3" placeholder="Path to your container">

+                <button id="inputContainer-btn" class="btn span1" type="button">Browse&hellip;</button>

+            </div>

+        </div>

+

+    </form>

+{% endblock %}

+{% block buttons %}

+    <a href="#" class="btn btn-success"><i class="icon-plus icon-white"></i> Add</a>

+    <a href="#" class="btn btn-close">Close</a>

+{% endblock %}
\ No newline at end of file
diff --git a/module/web/templates/default/backbone/modal.html b/module/web/templates/default/backbone/modal.html
new file mode 100755
index 000000000..ed618f3d0
--- /dev/null
+++ b/module/web/templates/default/backbone/modal.html
@@ -0,0 +1,15 @@
+<div class="modal-header">

+    <button type="button" class="close" data-dismiss="modal" aria-hidden="true">&times;</button>

+    <h3>{% block header%}Dialog{% endblock %}</h3>

+</div>

+<div class="modal-body">

+    {% block content %}

+    <% content %>

+    {% endblock %}

+</div>

+<div class="modal-footer">

+    {% block buttons %}

+    <a href="#" class="btn btn-close">Close</a>

+    <a href="#" class="btn btn-primary">Save</a>

+    {% endblock %}

+</div>
\ No newline at end of file
diff --git a/module/web/templates/default/backbone/queryDialog.html b/module/web/templates/default/backbone/queryDialog.html
new file mode 100755
index 000000000..a37ac6256
--- /dev/null
+++ b/module/web/templates/default/backbone/queryDialog.html
@@ -0,0 +1,25 @@
+{% extends 'default/backbone/modal.html' %}
+{% block header %}
+    <% title %>
+    <small style="background: url('icons/<% plugin %>') no-repeat right 0; background-size: 20px; padding-right: 22px">
+        <% plugin %>
+    </small>
+{% endblock %}
+{% block content %}
+    <form class="form-horizontal" action="#">
+        <legend><% description %></legend>
+        <div class="control-group">
+            <%= if captcha %>
+            <label class="control-label" for="inputText"><img src="data:image/<% type %>;base64,<% captcha %>"></label>
+            <div class="controls">
+                <input type="text" id="inputText" name="captcha">
+            </div>
+            <%/if%>
+            <% content %>
+        </div>
+    </form>
+{% endblock %}
+{% block buttons %}
+    <a href="#" class="btn btn-success">Submit</a>
+    <a href="#" class="btn btn-close">Close</a>
+{% endblock %}
\ No newline at end of file
diff --git a/module/web/templates/default/base.html b/module/web/templates/default/base.html
index 0b20ecdb0..846b396a0 100644
--- a/module/web/templates/default/base.html
+++ b/module/web/templates/default/base.html
@@ -1,180 +1,240 @@
-<?xml version="1.0" ?>

-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

-<html xmlns="http://www.w3.org/1999/xhtml">

+<!DOCTYPE html>

+{# TODO: set language from config #}

+<html lang="en">

 <head>

-

-<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>

-<link rel="stylesheet" type="text/css" href="/media/default/css/default.css"/>

-<link rel="stylesheet" type="text/css" href="/media/default/css/window.css"/>

-<link rel="stylesheet" type="text/css" href="/media/default/css/MooDialog.css"/>

-

-<script type="text/javascript" src="/media/js/mootools-core-1.4.1.js"></script>

-<script type="text/javascript" src="/media/js/mootools-more-1.4.0.1.js"></script>

-<script type="text/javascript" src="/media/js/MooDialog_static.js"></script>

-<script type="text/javascript" src="/media/js/purr_static.js"></script>

-

-

-<script type="text/javascript" src="/media/js/base.js"></script>

-

-<title>{% block title %}pyLoad {{_("Webinterface")}}{% endblock %}</title>

-

-{% block head %}

-{% endblock %}

-</head>

-<body>

-<a class="anchor" name="top" id="top"></a>

-

-<div id="head-panel">

-

-

-    <div id="head-search-and-login">

-    {% block headpanel %}

-

-        {% if user.is_authenticated %}

-

-

-{% if update %}

-<span>

-<span style="font-weight: bold; margin: 0 2px 0 2px;">{{_("pyLoad Update available!")}}</span>

-</span>

-{% endif %}

-

-

-{% if plugins %}

-<span>

-<span style="font-weight: bold; margin: 0 2px 0 2px;">{{_("Plugins updated, please restart!")}}</span>

-</span>

-{% endif %}

-

-<span id="cap_info" style="display: {% if captcha %}inline{%else%}none{% endif %}">

-<img src="/media/default/img/images.png" alt="Captcha:" style="vertical-align:middle; margin:2px" />

-<span style="font-weight: bold; cursor: pointer; margin-right: 2px;">{{_("Captcha waiting")}}</span>

-</span>

-

-    <img src="/media/default/img/head-login.png" alt="User:" style="vertical-align:middle; margin:2px" /><span style="padding-right: 2px;">{{user.name}}</span>

-	<ul id="user-actions">

-		<li><a href="/logout"  class="action logout" rel="nofollow">{{_("Logout")}}</a></li>

-		{% if user.is_admin %}

-		<li><a href="/admin" class="action profile" rel="nofollow">{{_("Administrate")}}</a></li>

-		{% endif %}

-        <li><a href="/info"  class="action info" rel="nofollow">{{_("Info")}}</a></li>

-

-	</ul>

-{% else %}

-    <span style="padding-right: 2px;">{{_("Please Login!")}}</span>

-{% endif %}

-

+    <meta charset="utf-8">

+    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">

+    <title>{% block title %}pyLoad WebUI{% endblock %}</title>

+    <meta name="description" content="pyLoad WebUI">

+    <meta name="viewport" content="width=device-width">

+

+    <!-- TODO Include this font -->

+    <link href="http://fonts.googleapis.com/css?family=Abel" rel="stylesheet" type="text/css"/>

+    <link href="/static/css/bootstrap.css" rel="stylesheet" type="text/css"/>

+    <link href="/static/css/select2.css" rel="stylesheet" type="text/css"/>

+    <link href="/static/css/font.css" rel="stylesheet" type="text/css"/>

+    <link href="/static/css/fontawesome.css" rel="stylesheet" type="text/css"/>

+    <link href="/static/css/default/style.less" rel="stylesheet/less" type="text/css" media="screen"/>

+    {% block css %}

     {% endblock %}

-	</div>

-

-	<a href="/"><img id="head-logo" src="/media/default/img/pyload-logo-edited3.5-new-font-small.png" alt="pyLoad" /></a>

-

-	<div id="head-menu">

-		<ul>

-

-        {% macro selected(name, right=False) -%}

-            {% if name in url -%}class="{% if right -%}right {% endif %}selected"{%- endif %}

-            {% if not name in url and right -%}class="right"{%- endif %}

-        {%- endmacro %}

-

-

-		{% block menu %}

-		<li>

-		    <a href="/" title=""><img src="/media/default/img/head-menu-home.png" alt="" /> {{_("Home")}}</a>

-		</li>

-		<li {{ selected('queue') }}>

-		    <a href="/queue/" title=""><img src="/media/default/img/head-menu-queue.png" alt="" /> {{_("Queue")}}</a>

-		</li>

-		<li {{ selected('collector') }}>

-		    <a href="/collector/" title=""><img src="/media/default/img/head-menu-collector.png" alt="" /> {{_("Collector")}}</a>

-		</li>

-		<li {{ selected('downloads') }}>

-		    <a href="/downloads/" title=""><img src="/media/default/img/head-menu-development.png" alt="" /> {{_("Downloads")}}</a>

-		</li>

-{#		<li {{ selected('filemanager') }}>#}

-{#		    <a href="/filemanager/" title=""><img src="/media/default/img/head-menu-download.png" alt="" /> {{_("FileManager")}}</a>#}

-{#		</li>#}

-		<li {{ selected('logs', True) }}>

-		    <a href="/logs/"  class="action index" accesskey="x" rel="nofollow"><img src="/media/default/img/head-menu-index.png" alt="" />{{_("Logs")}}</a>

-		</li>

-		<li {{ selected('settings', True) }}>

-		    <a href="/settings/"  class="action index" accesskey="x" rel="nofollow"><img src="/media/default/img/head-menu-config.png" alt="" />{{_("Config")}}</a>

-		</li>

-		{% endblock %}

-		

-		</ul>

-	</div>

-

-	<div style="clear:both;"></div>

-</div>

-

-{% if perms.STATUS %}

-<ul id="page-actions2">

-	<li id="action_play"><a href="#"  class="action play" accesskey="o" rel="nofollow">{{_("Start")}}</a></li>

-    <li id="action_stop"><a href="#"  class="action stop" accesskey="o" rel="nofollow">{{_("Stop")}}</a></li>

-    <li id="action_cancel"><a href="#"  class="action cancel" accesskey="o" rel="nofollow">{{_("Cancel")}}</a></li>

-    <li id="action_add"><a href="#"  class="action add" accesskey="o" rel="nofollow" >{{_("Add")}}</a></li>

-</ul>

-{% endif %}

 

-{% if perms.LIST %}

-<ul id="page-actions">

-    <li><span class="time">{{_("Download:")}}</span><a id="time" style=" background-color: {% if status.download %}#8ffc25{% else %} #fc6e26{% endif %}; padding-left: 0cm; padding-right: 0.1cm; "> {% if status.download %}{{_("on")}}{% else %}{{_("off")}}{% endif %}</a></li>

-    <li><span class="reconnect">{{_("Reconnect:")}}</span><a id="reconnect" style=" background-color: {% if status.reconnect %}#8ffc25{% else %} #fc6e26{% endif %}; padding-left: 0cm; padding-right: 0.1cm; "> {% if status.reconnect %}{{_("on")}}{% else %}{{_("off")}}{% endif %}</a></li>

-    <li><a class="action backlink">{{_("Speed:")}} <b id="speed">{{ status.speed }}</b></a></li>

-    <li><a class="action cog">{{_("Active:")}} <b id="aktiv" title="{{_("Active")}}">{{ status.active }}</b> / <b id="aktiv_from" title="{{_("Queued")}}">{{ status.queue }}</b> / <b id="aktiv_total" title="{{_("Total")}}">{{ status.total }}</b></a></li>

-    <li><a href=""  class="action revisions" accesskey="o" rel="nofollow">{{_("Reload page")}}</a></li>

-</ul>

-{% endif %}

-

-{% block pageactions %}

-{% endblock %}

-<br/>

-

-<div id="body-wrapper" class="dokuwiki">

-

-<div id="content" lang="en" dir="ltr">

-

-<h1>{% block subtitle %}pyLoad - {{_("Webinterface")}}{% endblock %}</h1>

-

-{% block statusbar %}

-{% endblock %}

-

-

-<br/>

-

-<div class="level1" style="clear:both">

-</div>

-<noscript><h1>Enable JavaScript to use the webinterface.</h1></noscript>

-

-{% for message in messages %}

-	<b><p>{{message}}</p></b>

-{% endfor %}

-

-<div id="load-indicator" style="opacity: 0; float: right; margin-top: -10px;">

-    <img src="/media/default/img/ajax-loader.gif" alt="" style="padding-right: 5px"/>

-    {{_("loading")}}

-</div>

-

-{% block content %}

-{% endblock content %}

-

-	<hr style="clear: both;" />

-

-<div id="foot">&copy; 2008-2011 pyLoad Team

-<a href="#top" class="action top" accesskey="x"><span>{{_("Back to top")}}</span></a><br />

-<!--<div class="breadcrumbs"></div>-->

-

-</div>

-</div>

-</div>

-

-<div style="display: none;">

-    {% include "default/window.html" %}

-    {% include "default/captcha.html" %}

-    {% block hidden %}

+    <script src="/static/js/libs/less-1.3.0.min.js" type="text/javascript"></script>

+    <script type="text/javascript" data-main="static/js/config" src="/static/js/libs/require-2.1.5.js"></script>

+    <script>

+        window.dates = {

+            weeks: ['week', 'weeks'],

+            days: ['day', 'days'],

+            hours: ['hour', 'hours'],

+            minutes: ['minute', 'minutes'],

+            seconds: ['second', 'seconds']

+        }; // TODO carefully when translating

+

+        window.wsAddress = "{{ ws }}";

+        window.pathPrefix = ""; // TODO

+

+        require(['default'], function(App) {

+            App.init();

+            {% block require %}

+            {% endblock %}

+        });

+    </script>

+    <script type="text/template" id="template-header">

+        <%= if single %>

+            <% name %> (<% statusmsg %>)

+        <% else %>

+            <%= if downloads %>

+                <% downloads %> downloads running <%= if speed %>(<% formatSize speed %>/s)<%/if%>

+            <% else %>

+                No running tasks

+            <%/if%>

+        <%/if%>

+        <i class="iconf-list pull-right"></i>

+

+{#  TODO: active animation      #}

+        <div class="progress" id="globalprogress">

+            <%= if single %>

+                <div class="bar" style="width: <% percent %>%">

+            <% else %>

+                <div class="bar <%= if downloads %>running<%/if%>">

+            <%/if%>

+            </div>

+        </div>

+        <div class="sub">

+        <%= if linksqueue %>

+            <% linksqueue %> downloads left (<% formatSize sizequeue %>)

+        <%/if%>

+        <span class="pull-right">

+            <% formatTime etaqueue %>

+        </span>

+        </div>

+    </script>

+    <script type="text/template" id="template-header-status">

+        <span class="pull-right maxspeed"><% formatSize maxspeed %>/s</span><br>

+        <span class="pull-right running"><% paused %></span><br>

+        <span class="pull-right reconnect"><%= if reconnect %>true<% else %>false<%/if%></span>

+    </script>

+

+    <script type="text/template" id="template-header-progress">

+        {# background-image for logo #}

+        <% name %>

+        <span class="pull-right"><% plugin %></span>

+

+        <div class="progress">

+            <div class="bar" style="width: <% percent %>%"></div>

+        </div>

+        <%= if downloading %>

+            <% formatSize done %> of <% formatSize total %> (<% formatSize download.speed %>/s)

+        <% else %>

+            <% statusmsg %>

+        <%/if%>

+        <span class="pull-right">

+{#            <% percent %>%#}

+            <% formatTime eta %>

+        </span>

+    </script>

+

+    <script type="text/template" id="template-notification">

+        <%= if queries %>

+        <span class="btn-query">

+        Queries <span class="badge badge-info"><% queries %></span>

+        </span>

+        <%/if%>

+        <%= if notifications %>

+        <span class="btn-notification">

+        Notifications <span class="badge badge-success"><% notifications %></span>

+        </span>

+        <%/if%>

+    </%if%>

+    </script>

+

+    {% block head %}

     {% endblock %}

+</head>

+<body>

+<div id="wrap">

+    <header>

+        <div class="left">

+            <div class="logo"></div>

+            <span class="title visible-large-screen">pyLoad</span>

+        </div>

+        <div class="right">

+            {% if user %}

+                <div class="header_block">

+                    {#                    <a class="header-link" href="/settings"><i class="icon-cog icon-white"></i> Settings</a>#}

+                    {#                    <a class="header-link" href="#"><i class="icon-list-alt icon-white"></i> Accounts</a>#}

+                    <span class="iconbar">

+                        <i class="iconf-play iconf-large"></i>&nbsp; Running&nbsp;&nbsp;

+                        <i class="iconf-repeat iconf-large"></i>&nbsp; Reconnect

+                    </span>

+                    <br>

+                    <a class="btn btn-success btn-grabber" href="#"><i class="icon-plus icon-white"></i> Add</a>

+

+                    <div class="btn-group">

+                        <a class="btn btn-blue" href="#"><i class="icon-user icon-white"></i> User</a>

+                        <a class="btn btn-blue dropdown-toggle" data-toggle="dropdown" href="#"><span

+                                class="caret"></span></a>

+                        <ul class="dropdown-menu" style="right: 0; left: -100%">

+                            <li><a href="/"><i class="iconf-list-alt"></i> Dashboard</a></li>

+                            <li><a href="/settings"><i class="iconf-wrench"></i> Settings</a></li>

+                            <li><a href="/admin"><i class="iconf-cogs"></i> Admin</a></li>

+                            <li class="divider"></li>

+                            <li><a href="/logout"><i class="iconf-signout"></i> Logout</a></li>

+                        </ul>

+                    </div>

+

+                </div>

+

+                <div id="speedgraph" class="visible-desktop"></div>

+

+                <div class="header_block right-border status-block">

+                </div>

+                <div class="header_block left-border">

+                    <i class="icon-download-alt icon-white"></i> Max. Speed:<br>

+                    <i class=" icon-off icon-white"></i> Running:<br>

+                    <i class="icon-refresh icon-white"></i> Reconnect:<br>

+                </div>

+

+                <div id="progress-area">

+                    <span id="progress-info">

+                    </span>

+                    <div class="popover bottom">

+                        <div class="arrow"></div>

+                        <div class="popover-inner">

+                            <h3 class="popover-title">

+                                Running...

+                                <button type="button" class="close" aria-hidden="true">&times;</button>

+                            </h3>

+                            <div class="popover-content">

+                                <ul class="progress-list"></ul>

+                            </div>

+                        </div>

+                    </div>

+                </div>

+            {% endif %}

+        </div>

+        <div id="notification-area">

+        </div>

+        <div id="selection-area">

+        </div>

+    </header>

+    <div id="content-container" class="container-fluid">

+        <div class="row-fluid">

+            <div class="span2 offset1">

+                {# just a placeholder #}

+            </div>

+            {% block actionbar %}

+            {% endblock %}

+        </div>

+        <div class="row-fluid" id="content">

+            {#            TODO: messages #}

+            {% for msg in messages %}

+                <p>{{ msg }}</p>

+            {% endfor %}

+

+            {% block content %}

+            {% endblock content %}

+        </div>

+    </div>

 </div>

+<footer>

+    <div class="center">

+        <div class="logo"></div>

+        <div class="block copyright">

+            © 2008-2013<br>

+            <a href="http://pyload.org/" target="_blank">The pyLoad Team</a><br>

+        </div>

+

+        <div class="block">

+            <h2 class="block-title">Powered by</h2>

+            Bootstrap <br>

+            Backbone <br>

+            sdf dsg <br>

+        </div>

+

+        <div class="block">

+            <h2 class="block-title">pyLoad</h2>

+            <a href="/toggle_mobile">{{ _("Mobile Version") }}</a> <br>

+            dsfdsf <br>

+            sdf dsg <br>

+        </div>

+

+        <div class="block">

+            <h2 class="block-title">Community</h2>

+            asd <br>

+            dsfdsf <br>

+            sdf dsg <br>

+        </div>

+

+        <div class="block">

+            <h2 class="block-title">Development</h2>

+            asd <br>

+            dsfdsf <br>

+            sdf dsg <br>

+        </div>

+    </div>

+</footer>

+<div id="modal-overlay" class="hide"></div>

+{% block deferred %}

+{% endblock deferred %}

 </body>

 </html>

diff --git a/module/web/templates/default/captcha.html b/module/web/templates/default/captcha.html
deleted file mode 100644
index 332a9c102..000000000
--- a/module/web/templates/default/captcha.html
+++ /dev/null
@@ -1,42 +0,0 @@
-<!-- Captcha box -->

-<div id="cap_box" class="window_box">

-

-	<form id="cap_form" action="/json/set_captcha" method="POST" enctype="multipart/form-data" onsubmit="return false;">

-	

-		<h1>{{_("Captcha reading")}}</h1>

-		<p id="cap_title">{{_("Please read the text on the captcha.")}}</p>

-		

-		<div id="cap_textual">

-		

-			<input id="cap_id" name="cap_id" type="hidden" value="" />

-		

-			<label>{{_("Captcha")}}

-			<span class="small">{{_("The captcha.")}}</span>

-			</label>

-			<span class="cont">

-			    <img id="cap_textual_img" src="">

-			</span>

-			

-			<label>{{_("Text")}}

-			<span class="small">{{_("Input the text on the captcha.")}}</span>

-			</label>

-			<input id="cap_result" name="cap_result" type="text" size="20" />

-					

-		</div>

-		

-		<div id="cap_positional" style="text-align: center">

-		    <img id="cap_positional_img" src="" style="margin: 10px; cursor:pointer">

-		</div>

-

-		<div id="button_bar" style="text-align: center">

-			<span>

-				<button id="cap_submit" type="submit" style="margin-left: 0">{{_("Submit")}}</button>

-				<button id="cap_reset" type="reset" style="margin-left: 0">{{_("Close")}}</button>

-			</span>

-		</div>

-		

-		<div class="spacer"></div>

-	

-	</form>

-

-</div>
\ No newline at end of file
diff --git a/module/web/templates/default/dashboard.html b/module/web/templates/default/dashboard.html
new file mode 100644
index 000000000..bb2a68cbf
--- /dev/null
+++ b/module/web/templates/default/dashboard.html
@@ -0,0 +1,213 @@
+{% extends 'default/base.html' %}

+{% block title %}

+    {{ _("Dashboard") }} - {{ super() }}

+{% endblock %}

+

+{% block css %}

+    <link href="static/css/default/dashboard.less" rel="stylesheet/less" type="text/css" media="screen"/>

+{% endblock %}

+

+{% block require %}

+    App.initDashboard();

+{% endblock %}

+

+{% block head %}

+    <script type="text/template" id="template-package">

+        <%= if selected %>

+        <i class="iconf-check select"></i>

+        <% else %>

+        <i class="iconf-check-empty select"></i>

+        <%/if%>

+        <span class="package-name">

+        <% name %>

+        </span>

+

+        <div class="package-frame">

+            <div class="tag-area">

+                <span class="badge badge-success"><i class="iconf-tag"></i>video</span>

+                <span class="badge badge-success badge-ghost"><i class="iconf-tag"></i> Add Tag</span>

+            </div>

+            <div class="package-indicator">

+                <i class="iconf-plus-sign btn-move" data-toggle="tooltip" title="Move files here"></i>

+                <i class="iconf-pause" data-toggle="tooltip" title="Pause Package"></i>

+                <i class="iconf-refresh" data-toggle="tooltip" title="Restart Package"></i>

+                <%= if shared %>

+                <i class="iconf-eye-open" data-toggle="tooltip" title="Package is public"></i>

+                <% else %>

+                <i class="iconf-eye-close" data-toggle="tooltip" title="Package is private"></i>

+                <%/if%>

+                <i class="iconf-chevron-down" data-toggle="dropdown">

+                </i>

+                <ul class="dropdown-menu" role="menu">

+                    <li><a href="#" class="btn-open"><i class="iconf-folder-open-alt"></i> Open</a></li>

+                    <li><a href="#"><i class="iconf-plus-sign"></i> Add links</a></li>

+                    <li><a href="#"><i class="iconf-edit"></i> Details</a></li>

+                    <li><a href="#" class="btn-delete"><i class="iconf-trash"></i> Delete</a></li>

+                    <li><a href="#" class="btn-recheck"><i class="iconf-refresh"></i> Recheck</a></li>

+                    <li class="divider"></li>

+                    <li class="dropdown-submenu">

+                        <a>Addons</a>

+                        <ul class="dropdown-menu">

+                            <li><a>Test</a></li>

+                        </ul>

+                    </li>

+                </ul>

+            </div>

+            <div class="progress">

+                <span style="position: absolute; left: 5px">

+                    <% stats.linksdone %> / <% stats.linkstotal %>

+                </span>

+                <div class="bar bar-info" style="width: <% percent %>%"></div>

+                <span style="position: absolute; right: 5px">

+                        <% formatSize stats.sizedone %> / <% formatSize stats.sizetotal %>

+                </span>

+            </div>

+        </div>

+    </script>

+

+    <script type="text/template" id="template-file">

+        <div class="file-row first span6">

+            <i class="checkbox"></i>&nbsp;

+            <span class="name">

+            <% name %>

+            </span>

+        </div>

+        <div class="file-row second span3 <% fileClass this %>">

+            <% fileStatus this %>

+        </div>

+

+        <div class="file-row third span3 pull-right">

+            <i class="<% fileIcon media %>"></i>&nbsp;

+            <% formatSize size %>

+            <span class="pull-right">

+                <img src="icons/<% download.plugin %>"/>

+                <% download.plugin %>&nbsp;

+                <i class="iconf-chevron-down" data-toggle="dropdown"></i>

+                <ul class="dropdown-menu" role="menu">

+                    <li><a href="#" class="btn-delete"><i class="iconf-trash"></i> Delete</a></li>

+                    <li><a href="#" class="btn-restart"><i class="iconf-refresh"></i> Restart</a></li>

+                    <li><a href="#" class="btn-dowload"><i class="iconf-download"></i> Download</a></li>

+                    <li><a href="#" class="btn-share"><i class="iconf-share"></i> Share</a></li>

+                    <li class="divider"></li>

+                    <li class="dropdown-submenu pull-left">

+                        <a>Addons</a>

+                        <ul class="dropdown-menu">

+                            <li><a>Test</a></li>

+                        </ul>

+                    </li>

+                </ul>

+            </span>

+        </div>

+    </script>

+

+    <script type="text/template" id="template-select">

+        <i class="iconf-check" data-toggle="tooltip" title="Deselect"></i>&nbsp;

+        <%= if packs %><% packs %> package(s)<%/if %>

+        <%= if files %>

+        <%= if packs %>, <%/if %>

+        <% files %> file(s)

+        <%/if %>

+        selected

+        &nbsp;|&nbsp;

+        <i class="iconf-pause" data-toggle="tooltip" title="Pause"></i>&nbsp;

+        <i class="iconf-trash" data-toggle="tooltip" title="Delete"></i>&nbsp;

+        <i class="iconf-refresh" data-toggle="tooltip" title="Restart"></i>

+    </script>

+

+{% endblock %}

+

+{% block actionbar %}

+    <ul class="actionbar nav nav-pills span9">

+        <li>

+            <ul class="breadcrumb">

+                <li><a href="#">{{ _("Local") }}</a> <span class="divider">/</span></li>

+                <li class="active"></li>

+            </ul>

+        </li>

+

+        <li style="float: right;">

+            <form class="form-search" action="#">

+                <div class="input-append">

+                    <input type="text" class="search-query" style="width: 120px">

+                    <button type="submit" class="btn">{{ _("Search") }}</button>

+                </div>

+            </form>

+        </li>

+        <li style="float: right">

+            <a href="#"><i class="iconf-check-empty btn-check"></i></a>

+        </li>

+        <li class="dropdown" style="float: right;">

+            <a class="dropdown-toggle type"

+               data-toggle="dropdown"

+               href="#">

+                Type

+                <b class="caret"></b>

+            </a>

+            <ul class="dropdown-menu">

+                <li><a class="filter-type" data-type="2" href="#"><i class="icon-ok"></i>&nbsp;Audio</a></li>

+                <li><a class="filter-type" data-type="4" href="#"><i class="icon-ok"></i>&nbsp;Image</a></li>

+                <li><a class="filter-type" data-type="8" href="#"><i class="icon-ok"></i>&nbsp;Video</a></li>

+                <li><a class="filter-type" data-type="16" href="#"><i class="icon-ok"></i>&nbsp;Document</a></li>

+                <li><a class="filter-type" data-type="32" href="#"><i class="icon-remove"></i>&nbsp;Archive</a></li>

+                <li><a class="filter-type" data-type="1" href="#"><i class="icon-remove"></i>&nbsp;Other</a></li>

+            </ul>

+        </li>

+        <li class="dropdown" style="float: right;">

+            <a class="dropdown-toggle"

+               data-toggle="dropdown"

+               href="#">

+                <span class="state">

+                    All

+                </span>

+                <b class="caret"></b>

+            </a>

+            <ul class="dropdown-menu">

+                <li><a class="filter-state" data-state="0" href="#">All</a></li>

+                <li><a class="filter-state" data-state="1" href="#">Finished</a></li>

+                <li><a class="filter-state" data-state="2" href="#">Unfinished</a></li>

+                <li><a class="filter-state" data-state="3" href="#">Failed</a></li>

+            </ul>

+        </li>

+    </ul>

+{% endblock %}

+

+

+{% block content %}

+

+    <div class="span3">

+        <div class="sidebar-header">

+            <i class="iconf-hdd"></i> Local

+            <div class="pull-right" style="font-size: medium; line-height: normal">

+                {#                <input type="text" class="input">#}

+                <i class="iconf-chevron-down" style="font-size: 20px"></i>

+            </div>

+            <div class="clearfix"></div>

+        </div>

+        <ul class="package-list">

+            {# Build up by js #}

+        </ul>

+        <div class="sidebar-header">

+            <i class="iconf-group"></i> Shared

+        </div>

+        <ul class="package-list">

+            <li>Content from</li>

+            <li>Other user</li>

+            <li>which they shared</li>

+        </ul>

+        <div class="sidebar-header">

+            <i class="iconf-sitemap"></i> Remote

+        </div>

+        <ul>

+            <li>Content from</li>

+            <li>remote sites</li>

+            <li>mega</li>

+            <li>dropbox</li>

+            <li>other pyloads</li>

+        </ul>

+    </div>

+    <div class="span9">

+        <ul class="file-list">

+            {#  Build up by js #}

+        </ul>

+    </div>

+{% endblock %}
\ No newline at end of file
diff --git a/module/web/templates/default/downloads.html b/module/web/templates/default/downloads.html
deleted file mode 100644
index 450b8a102..000000000
--- a/module/web/templates/default/downloads.html
+++ /dev/null
@@ -1,29 +0,0 @@
-{% extends 'default/base.html' %}
-
-{% block title %}Downloads - {{super()}} {% endblock %}
-
-{% block subtitle %}
-{{_("Downloads")}}
-{% endblock %}
-
-{% block content %}
-
-<ul>
-    {% for folder in files.folder %}
-    <li>
-        {{ folder.name }}
-        <ul>
-        {% for file in folder.files %}
-        <li><a href='get/{{ folder.path|escape }}/{{ file|escape }}'>{{file}}</a></li>
-        {% endfor %}
-        </ul>
-    </li>
-    {% endfor %}
-    
-    {% for file in files.files %}
-    <li> <a href='get/{{ file|escape }}'>{{ file }}</a></li>
-    {% endfor %}
-
-</ul>
-
-{% endblock %}
\ No newline at end of file
diff --git a/module/web/templates/default/filemanager.html b/module/web/templates/default/filemanager.html
deleted file mode 100644
index 97095c13e..000000000
--- a/module/web/templates/default/filemanager.html
+++ /dev/null
@@ -1,80 +0,0 @@
-{% extends 'default/base.html' %}
-
-{% block head %}
-
-<script type="text/javascript" src="/filemanager_ui.js"></script>
-
-<script type="text/javascript">
-
-document.addEvent("domready", function(){
-    var fmUI = new FilemanagerUI("url",1);
-});
-</script>
-{% endblock %}
-
-{% block title %}Downloads - {{super()}} {% endblock %}
-
-
-{% block subtitle %}
-{{_("FileManager")}}
-{% endblock %}
-
-{% macro display_file(file) %}
-  <li class="file">
-    <input type="hidden" name="path" class="path" value="{{ file.path }}" />
-    <input type="hidden" name="name" class="name" value="{{ file.name }}" />
-    <span>
-      <b>{{ file.name }}</b>
-      <span class="buttons" style="opacity:0">
-	    <img title="{{_("Rename Directory")}}" class="rename" style="cursor: pointer" height="12px" src="/media/default/img/pencil.png" />
-	    &nbsp;&nbsp;
-	    <img title="{{_("Delete Directory")}}" class="delete" style="margin-left: -10px; cursor: pointer" width="12px" height="12px" src="/media/default/img/delete.png" />
-      </span>
-    </span>
-  </li>
-{%- endmacro %}
-
-{% macro display_folder(fld, open = false) -%}
-    <li class="folder">
-      <input type="hidden" name="path" class="path" value="{{ fld.path }}" />
-      <input type="hidden" name="name" class="name" value="{{ fld.name }}" />
-      <span>
-	<b>{{ fld.name }}</b>
-	<span class="buttons" style="opacity:0">
-	      <img title="{{_("Rename Directory")}}" class="rename" style="cursor: pointer" height="12px" src="/media/default/img/pencil.png" />
-	      &nbsp;&nbsp;
-	      <img title="{{_("Delete Directory")}}" class="delete" style="margin-left: -10px; cursor: pointer" width="12px" height="12px" src="/media/default/img/delete.png" />
-	      &nbsp;&nbsp;
-	      <img title="{{_("Add subdirectory")}}" class="mkdir" style="margin-left: -10px; cursor: pointer" width="12px" height="12px" src="/media/default/img/add_folder.png" />
-	</span>
-      </span>
-      {% if (fld.folders|length + fld.files|length) > 0 %}
-	{% if open %}
-	  <ul>
-	{% else %}
-	  <ul style="display:none">
-	{% endif %}
-	  {% for child in fld.folders %}
-	      {{ display_folder(child) }}
-	  {% endfor %}
-	  {% for child in fld.files %}
-	      {{ display_file(child) }}
-	  {% endfor %}
-	</ul>
-      {% else %}
-	<div style="display:none">{{ _("Folder is empty") }}</div>
-      {% endif %}
-    </li>
-{%- endmacro %}
-
-{% block content %}
-
-<div style="clear:both"><!-- --></div>
-
-<ul id="directories-list">
-{{ display_folder(root, true) }}
-</ul>
-
-{% include "default/rename_directory.html" %}
-
-{% endblock %}
diff --git a/module/web/templates/default/filemanager_ui.js b/module/web/templates/default/filemanager_ui.js
deleted file mode 100644
index ed64ab69d..000000000
--- a/module/web/templates/default/filemanager_ui.js
+++ /dev/null
@@ -1,291 +0,0 @@
-var load, rename_box, confirm_box;
-
-document.addEvent("domready", function() {
-    load = new Fx.Tween($("load-indicator"), {link: "cancel"});
-    load.set("opacity", 0);
-
-    rename_box = new Fx.Tween($('rename_box'));
-    confirm_box = new Fx.Tween($('confirm_box'));
-    $('rename_reset').addEvent('click', function() {
-        hide_rename_box()
-    });
-    $('delete_reset').addEvent('click', function() {
-        hide_confirm_box()
-    });
-        
-    /*$('filemanager_actions_list').getChildren("li").each(function(action) {
-      var action_name = action.className;
-      if(functions[action.className] != undefined)
-      {
-	action.addEvent('click', functions[action.className]);
-      }
-    });*/
-});
-
-function indicateLoad() {
-    //$("load-indicator").reveal();
-    load.start("opacity", 1)
-}
-
-function indicateFinish() {
-    load.start("opacity", 0)
-}
-
-function indicateSuccess() {
-    indicateFinish();
-    notify.alert('{{_("Success")}}.', {
-             'className': 'success'
-    });
-}
-
-function indicateFail() {
-    indicateFinish();
-    notify.alert('{{_("Failed")}}.', {
-             'className': 'error'
-    });
-}
-
-function show_rename_box() {
-    bg_show();
-    $("rename_box").setStyle('display', 'block');
-    rename_box.start('opacity', 1)
-}
-
-function hide_rename_box() {
-    bg_hide();
-    rename_box.start('opacity', 0).chain(function() {
-        $('rename_box').setStyle('display', 'none');
-    });
-}
-
-function show_confirm_box() {
-    bg_show();
-    $("confirm_box").setStyle('display', 'block');
-    confirm_box.start('opacity', 1)
-}
-
-function hide_confirm_box() {
-    bg_hide();
-    confirm_box.start('opacity', 0).chain(function() {
-        $('confirm_box').setStyle('display', 'none');
-    });
-}
-
-var FilemanagerUI = new Class({
-    initialize: function(url, type) {
-        this.url = url;
-        this.type = type;
-        this.directories = [];
-	this.files = [];
-        this.parseChildren();
-    },
-
-    parseChildren: function() {
-        $("directories-list").getChildren("li.folder").each(function(ele) {
-            var path = ele.getElements("input.path")[0].get("value");
-            var name = ele.getElements("input.name")[0].get("value");
-            this.directories.push(new Item(this, path, name, ele))
-        }.bind(this));
-	
-	$("directories-list").getChildren("li.file").each(function(ele) {
-            var path = ele.getElements("input.path")[0].get("value");
-            var name = ele.getElements("input.name")[0].get("value");
-            this.files.push(new Item(this, path, name, ele))
-        }.bind(this));
-    }
-});
-
-var Item = new Class({
-    initialize: function(ui, path, name, ele) {
-        this.ui = ui;
-	this.path = path;
-	this.name = name;
-        this.ele = ele;
-	this.directories = [];
-	this.files = [];
-	this.actions = new Array();
-	this.actions["delete"] = this.del;
-	this.actions["rename"] = this.rename;
-	this.actions["mkdir"] = this.mkdir;
-        this.parseElement();
-        
-        var pname = this.ele.getElements("span")[0];
-        this.buttons = new Fx.Tween(this.ele.getElements(".buttons")[0], {link: "cancel"});
-        this.buttons.set("opacity", 0);
-
-        pname.addEvent("mouseenter", function(e) {
-            this.buttons.start("opacity", 1)
-        }.bind(this));
-
-        pname.addEvent("mouseleave", function(e) {
-            this.buttons.start("opacity", 0)
-        }.bind(this));
-
-    },
-
-    parseElement: function() {
-        this.ele.getChildren('span span.buttons img').each(function(img) {
-	  img.addEvent('click', this.actions[img.className].bind(this));
-	}, this);
-
-	//click on the directory name must open the directory itself
-	this.ele.getElements('b')[0].addEvent('click', this.toggle.bind(this));
-	
-	//iterate over child directories
-	var uls = this.ele.getElements('ul');
-	if(uls.length > 0)
-	{
-	  uls[0].getChildren("li.folder").each(function(fld) {
-	    var path = fld.getElements("input.path")[0].get("value");
-	    var name = fld.getElements("input.name")[0].get("value");
-	    this.directories.push(new Item(this, path, name, fld));
-	  }.bind(this));
-	  uls[0].getChildren("li.file").each(function(fld) {
-	    var path = fld.getElements("input.path")[0].get("value");
-	    var name = fld.getElements("input.name")[0].get("value");
-	    this.files.push(new Item(this, path, name, fld));
-	  }.bind(this));
-	}
-    },
-
-    reorderElements: function() {
-      //TODO sort the main ul again (to keep data ordered after renaming something)
-    },
-    
-    del: function(event) {
-        $("confirm_form").removeEvents("submit");
-        $("confirm_form").addEvent("submit", this.deleteDirectory.bind(this));
-
-	$$("#confirm_form p").set('html', '{{_(("Are you sure you want to delete the selected item?"))}}');
-	
-        show_confirm_box();
-        event.stop();
-    },
-    
-    deleteDirectory: function(event) {
-        hide_confirm_box();
-	new Request.JSON({
-            method: 'POST',
-            url: "/json/filemanager/delete",
-	    data: {"path": this.path, "name": this.name},
-            onSuccess: function(data) {
-		if(data.response == "success")
-		{
-		  new Fx.Tween(this.ele).start('opacity', 0);
-		  var ul = this.ele.parentNode;
-		  this.ele.dispose();
-		  //if this was the only child, add a "empty folder" div
-		  if(!ul.getChildren('li')[0])
-		  {
-		    var div = new Element("div", { 'html': '{{ _("Folder is empty") }}' });
-		    div.replaces(ul);
-		  }
-		  
-		  indicateSuccess();
-		} else
-		{
-		  //error from json code...
-		  indicateFail();
-		}
-            }.bind(this),
-            onFailure: indicateFail
-        }).send();
-	
-        event.stop();
-    },
-    
-    rename: function(event) {
-        $("rename_form").removeEvents("submit");
-        $("rename_form").addEvent("submit", this.renameDirectory.bind(this));
-
-	$("path").set("value", this.path);
-        $("old_name").set("value", this.name);
-        $("new_name").set("value", this.name);
-        
-        show_rename_box();
-        event.stop();
-    },
-
-    renameDirectory: function(event) {
-        hide_rename_box();
-	new Request.JSON({
-            method: 'POST',
-            url: "/json/filemanager/rename",
-            onSuccess: function(data) {
-		if(data.response == "success")
-		{
-		  this.name = $("new_name").get("value");
-		  this.ele.getElements("b")[0].set('html', $("new_name").get("value"));
-		  this.reorderElements();
-		  indicateSuccess();
-		} else
-		{
-		  //error from json code...
-		  indicateFail();
-		}
-            }.bind(this),
-            onFailure: indicateFail
-        }).send($("rename_form").toQueryString());
-	
-        event.stop();
-    },
-    
-    mkdir: function(event) {
-      new Request.JSON({
-	  method: 'POST',
-	  url: "/json/filemanager/mkdir",
-	  data: {"path": this.path + "/" + this.name, "name": '{{_("New folder")}}'},
-	  onSuccess: function(data) {
-	      if(data.response == "success")
-	      {
-		new Request.HTML({
-		    method: 'POST',
-		    url: "/filemanager/get_dir",
-		    data: {"path": data.path, "name": data.name},
-		    onSuccess: function(li) {
-			//add node as first child of ul
-			var ul = this.ele.getChildren('ul')[0];
-			if(!ul)
-			{
-			  //remove the "Folder Empty" div
-			  this.ele.getChildren('div').dispose();
-			  
-			  //create new ul to contain subfolder
-			  ul = new Element("ul");
-			  ul.inject(this.ele, 'bottom');
-			}
-			li[0].inject(ul, 'top');
-			
-			//add directory as a subdirectory of the current item
-			this.directories.push(new Item(this.ui, data.path, data.name, ul.firstChild));
-		    }.bind(this),
-		    onFailure: indicateFail
-		}).send();
-		indicateSuccess();
-	      } else
-	      {
-		//error from json code...
-		indicateFail();
-	      }
-	  }.bind(this),
-	  onFailure: indicateFail
-      }).send();
-      
-      event.stop();
-    },
-    
-    toggle: function() {
-        var child = this.ele.getElement('ul');
-	if(child == null)
-	  child = this.ele.getElement('div');
-	
-	if(child != null)
-	{
-	  if (child.getStyle('display') == "block") {
-	      child.dissolve();
-	  } else {
-	      child.reveal();
-	  }
-	}
-    }
-});
diff --git a/module/web/templates/default/folder.html b/module/web/templates/default/folder.html
deleted file mode 100644
index b385e80cb..000000000
--- a/module/web/templates/default/folder.html
+++ /dev/null
@@ -1,15 +0,0 @@
-<li class="folder">
-  <input type="hidden" name="path" class="path" value="{{ path }}" />
-  <input type="hidden" name="name" class="name" value="{{ name }}" />
-  <span>
-    <b>{{ name }}</b>
-    <span class="buttons" style="opacity:0">
-	  <img title="{{_("Rename Directory")}}" class="rename" style="cursor: pointer" height="12px" src="/media/default/img/pencil.png" />
-	  &nbsp;&nbsp;
-	  <img title="{{_("Delete Directory")}}" class="delete" style="margin-left: -10px; cursor: pointer" width="12px" height="12px" src="/media/default/img/delete.png" />
-	  &nbsp;&nbsp;
-	  <img title="{{_("Add subdirectory")}}" class="mkdir" style="margin-left: -10px; cursor: pointer" width="12px" height="12px" src="/media/default/img/add_folder.png" />
-    </span>
-  </span>
-  <div style="display:none">{{ _("Folder is empty") }}</div>
-</li>
\ No newline at end of file
diff --git a/module/web/templates/default/home.html b/module/web/templates/default/home.html
deleted file mode 100644
index 0efb1bcf8..000000000
--- a/module/web/templates/default/home.html
+++ /dev/null
@@ -1,266 +0,0 @@
-{% extends 'default/base.html' %}

-{% block head %}

-

-<script type="text/javascript">

-

-var em;

-var operafix = (navigator.userAgent.toLowerCase().search("opera") >= 0);

-

-document.addEvent("domready", function(){

-	em = new EntryManager();

-});

-

-var EntryManager = new Class({

-    initialize: function(){

-        this.json = new Request.JSON({

-		url: "json/links",

-                secure: false,

-                async: true,

-		onSuccess: this.update.bind(this),

-		initialDelay: 0,

-		delay: 2500,

-		limit: 30000

-	});

-	

-        this.ids = [{% for link in content %}

-        {% if forloop.last %}

-            {{ link.id }}

-        {% else %}

-         {{ link.id }},

-        {% endif %}

-        {% endfor %}];

-        

-        this.entries = [];

-        this.container = $('LinksAktiv');

-        

-        this.parseFromContent();

-            

-        this.json.startTimer();

-    },

-    parseFromContent: function(){

-        this.ids.each(function(id,index){

-            var entry = new LinkEntry(id);

-            entry.parse();

-            this.entries.push(entry)

-            }, this);

-    },

-    update: function(data){

-        

-        try{

-        this.ids = this.entries.map(function(item){

-            return item.fid

-            });

-        

-        this.ids.filter(function(id){

-            return !this.ids.contains(id)

-        },data).each(function(id){

-            var index = this.ids.indexOf(id);

-            this.entries[index].remove();

-            this.entries = this.entries.filter(function(item){return item.fid != this},id);

-            this.ids = this.ids.erase(id)

-            }, this);

-        

-        data.links.each(function(link, i){

-            if (this.ids.contains(link.fid)){

-                

-                var index = this.ids.indexOf(link.fid);

-                this.entries[index].update(link)

-            

-            }else{

-                var entry = new LinkEntry(link.fid);

-                entry.insert(link);

-                this.entries.push(entry);

-                this.ids.push(link.fid);

-                this.container.adopt(entry.elements.tr,entry.elements.pgbTr);

-                entry.fade.start('opacity', 1);

-                entry.fadeBar.start('opacity', 1);

-                

-            }

-            }, this)

-        }catch(e){

-            //alert(e)

-        }

-    }

-});

-

-

-var LinkEntry = new Class({

-        initialize: function(id){

-            this.fid = id;

-            this.id = id;

-        },

-        parse: function(){

-            this.elements = {

-                tr: $("link_{id}".substitute({id: this.id})),

-                name: $("link_{id}_name".substitute({id: this.id})),

-                status: $("link_{id}_status".substitute({id: this.id})),

-                info: $("link_{id}_info".substitute({id: this.id})),

-                bleft: $("link_{id}_bleft".substitute({id: this.id})),

-                percent: $("link_{id}_percent".substitute({id: this.id})),

-                remove: $("link_{id}_remove".substitute({id: this.id})),

-                pgbTr: $("link_{id}_pgb_tr".substitute({id: this.id})),

-                pgb: $("link_{id}_pgb".substitute({id: this.id}))

-            };

-            this.initEffects();

-        },

-        insert: function(item){

-            try{

-

-            this.elements = {

-                tr: new Element('tr', {

-                'html': '',

-                'styles':{

-                    'opacity': 0

-                }

-                }),

-                name: new Element('td', {

-                'html': item.name

-                }),

-                status: new Element('td', {

-                'html': item.statusmsg

-                }),

-                info: new Element('td', {

-                'html': item.info

-                }),

-                bleft: new Element('td', {

-                'html': humanFileSize(item.size)

-                }),

-                percent: new Element('span', {

-                'html': item.percent+ '% / '+ humanFileSize(item.size-item.bleft)

-                }),

-                remove: new Element('img',{

-                'src': 'media/default/img/control_cancel.png',

-                'styles':{

-                    'vertical-align': 'middle',

-                    'margin-right': '-20px',

-                    'margin-left': '5px',

-                    'margin-top': '-2px',

-                    'cursor': 'pointer'

-                }

-                }),

-                pgbTr: new Element('tr', {

-                'html':''

-                }),

-                pgb: new Element('div', {

-                'html': '&nbsp;',

-                'styles':{

-                    'height': '4px',

-                    'width': item.percent+'%',

-                    'background-color': '#ddd'

-                }

-                })

-            };

-            

-            this.elements.tr.adopt(this.elements.name,this.elements.status,this.elements.info,this.elements.bleft,new Element('td').adopt(this.elements.percent,this.elements.remove));

-            this.elements.pgbTr.adopt(new Element('td',{'colspan':5}).adopt(this.elements.pgb));

-            this.initEffects();

-            }catch(e){

-                alert(e)

-            }

-        },

-        initEffects: function(){

-            if(!operafix)

-                this.bar = new Fx.Morph(this.elements.pgb, {unit: '%', duration: 5000, link: 'link', fps:30});

-            this.fade = new Fx.Tween(this.elements.tr);

-            this.fadeBar = new Fx.Tween(this.elements.pgbTr);

-            

-            this.elements.remove.addEvent('click', function(){

-                new Request({method: 'get', url: '/json/abort_link/'+this.id}).send();

-            }.bind(this));

-            

-        },

-        update: function(item){

-                this.elements.name.set('text', item.name);

-                this.elements.status.set('text', item.statusmsg);

-                this.elements.info.set('text', item.info);

-                this.elements.bleft.set('text', item.format_size);

-                this.elements.percent.set('text', item.percent+ '% / '+ humanFileSize(item.size-item.bleft));

-                if(!operafix)

-                {

-                    this.bar.start({

-                        'width': item.percent,

-                        'background-color': [Math.round(120/100*item.percent),100,100].hsbToRgb().rgbToHex()

-                    });

-                }

-                else

-                {

-                    this.elements.pgb.set(

-                        'styles', {

-                            'height': '4px',

-                            'width': item.percent+'%',

-                            'background-color': [Math.round(120/100*item.percent),100,100].hsbToRgb().rgbToHex(),

-                         });

-                }

-        },

-        remove: function(){

-                this.fade.start('opacity',0).chain(function(){this.elements.tr.dispose();}.bind(this));

-                this.fadeBar.start('opacity',0).chain(function(){this.elements.pgbTr.dispose();}.bind(this));

-

-        }

-    });

-</script>

-

-{% endblock %}

-

-{% block subtitle %}

-{{_("Active Downloads")}}

-{% endblock %}

-

-{% block menu %}

-<li class="selected">

-    <a href="/" title=""><img src="/media/default/img/head-menu-home.png" alt="" /> {{_("Home")}}</a>

-</li>

-<li>

-    <a href="/queue/" title=""><img src="/media/default/img/head-menu-queue.png" alt="" /> {{_("Queue")}}</a>

-</li>

-<li>

-    <a href="/collector/" title=""><img src="/media/default/img/head-menu-collector.png" alt="" /> {{_("Collector")}}</a>

-</li>

-<li>

-    <a href="/downloads/" title=""><img src="/media/default/img/head-menu-development.png" alt="" /> {{_("Downloads")}}</a>

-</li>

-{#<li>#}

-{#    <a href="/filemanager/" title=""><img src="/media/default/img/head-menu-download.png" alt="" /> {{_("FileManager")}}</a>#}

-{#</li>#}

-<li class="right">

-    <a href="/logs/"  class="action index" accesskey="x" rel="nofollow"><img src="/media/default/img/head-menu-index.png" alt="" />{{_("Logs")}}</a>

-</li>

-<li class="right">

-    <a href="/settings/"  class="action index" accesskey="x" rel="nofollow"><img src="/media/default/img/head-menu-config.png" alt="" />{{_("Config")}}</a>

-</li>

-{% endblock %}

-

-{% block content %}

-<table width="100%" class="queue">

-    <thead>

-  <tr class="header">

-    <th>{{_("Name")}}</th>

-    <th>{{_("Status")}}</th>

-    <th>{{_("Information")}}</th>

-    <th>{{_("Size")}}</th>

-    <th>{{_("Progress")}}</th>

-  </tr>

-    </thead>

-  <tbody id="LinksAktiv">

-  

-  {% for link in content %}

-  <tr id="link_{{ link.id }}">

-    <td id="link_{{ link.id }}_name">{{ link.name }}</td>

-    <td id="link_{{ link.id }}_status">{{ link.status }}</td>

-    <td id="link_{{ link.id }}_info">{{ link.info }}</td>

-    <td id="link_{{ link.id }}_bleft">{{ link.format_size }}</td>

-    <td>

-        <span id="link_{{ link.id }}_percent">{{ link.percent }}% /{{ link.bleft }}</span>

-        <img id="link_{{ link.id }}_remove" style="vertical-align: middle; margin-right: -20px; margin-left: 5px; margin-top: -2px; cursor:pointer;" src="media/default/img/control_cancel.png"/>

-    </td>

-  </tr>

-  <tr id="link_{{ link.id }}_pgb_tr">

-    <td colspan="5">

-        <div id="link_{{ link.id }}_pgb" class="progressBar" style="background-color: green; height:4px; width: {{ link.percent }}%;">&nbsp;</div>

-    </td>

-  </tr>

-  {% endfor %}

-  

-  </tbody>

-</table>

-{% endblock %}
\ No newline at end of file
diff --git a/module/web/templates/default/info.html b/module/web/templates/default/info.html
deleted file mode 100644
index 77ae57376..000000000
--- a/module/web/templates/default/info.html
+++ /dev/null
@@ -1,81 +0,0 @@
-{% extends 'default/base.html' %}
-
-{% block head %}
-    <script type="text/javascript">
-        window.addEvent("domready", function() {
-            var ul = new Element('ul#twitter_update_list');
-            var script1 = new Element('script[src=http://twitter.com/javascripts/blogger.js][type=text/javascript]');
-            var script2 = new Element('script[src=http://twitter.com/statuses/user_timeline/pyLoad.json?callback=twitterCallback2&count=6][type=text/javascript]');
-            $("twitter").adopt(ul, script1, script2);
-        });
-    </script>
-{% endblock %}
-
-{% block title %}{{ _("Information") }} - {{ super() }} {% endblock %}
-{% block subtitle %}{{ _("Information") }}{% endblock %}
-
-{% block content %}
-    <h3>{{ _("News") }}</h3>
-    <div id="twitter"></div>
-
-    <h3>{{ _("Support") }}</h3>
-
-    <ul>
-        <li style="font-weight:bold;">
-            <a href="http://pyload.org/wiki" target="_blank">Wiki</a>
-            &nbsp;&nbsp;|&nbsp;&nbsp;
-            <a href="http://forum.pyload.org/" target="_blank">Forum</a>
-            &nbsp;&nbsp;|&nbsp;&nbsp;
-            <a href="http://pyload.org/irc/" target="_blank">Chat</a>
-        </li>
-        <li style="font-weight:bold;"><a href="http://docs.pyload.org" target="_blank">Documentation</a></li>
-        <li style="font-weight:bold;"><a href="https://bitbucket.org/spoob/pyload/overview" target="_blank">Development</a></li>
-        <li style="font-weight:bold;"><a href="https://bitbucket.org/spoob/pyload/issues?status=new&status=open" target="_blank">Issue Tracker</a></li>
-
-    </ul>
-
-    <h3>{{ _("System") }}</h3>
-    <table class="system">
-         <tr>
-            <td>{{ _("Python:") }}</td>
-            <td>{{ python }}</td>
-        </tr>
-        <tr>
-            <td>{{ _("OS:") }}</td>
-            <td>{{ os }}</td>
-        </tr>
-        <tr>
-            <td>{{ _("pyLoad version:") }}</td>
-            <td>{{ version }}</td>
-        </tr>
-        <tr>
-            <td>{{ _("Installation Folder:") }}</td>
-            <td>{{ folder }}</td>
-        </tr>
-        <tr>
-            <td>{{ _("Config Folder:") }}</td>
-            <td>{{ config }}</td>
-        </tr>
-        <tr>
-            <td>{{ _("Download Folder:") }}</td>
-            <td>{{ download }}</td>
-        </tr>
-        <tr>
-            <td>{{ _("Free Space:") }}</td>
-            <td>{{ freespace }}</td>
-        </tr>
-        <tr>
-            <td>{{ _("Language:") }}</td>
-            <td>{{ language }}</td>
-        </tr>
-        <tr>
-            <td>{{ _("Webinterface Port:") }}</td>
-            <td>{{ webif }}</td>
-        </tr>
-        <tr>
-            <td>{{ _("Remote Interface Port:") }}</td>
-            <td>{{ remote }}</td>
-        </tr>
-    </table>
-
-{% endblock %}
\ No newline at end of file
diff --git a/module/web/templates/default/login.html b/module/web/templates/default/login.html
index 9e91ad309..c8cd78a33 100644
--- a/module/web/templates/default/login.html
+++ b/module/web/templates/default/login.html
@@ -1,36 +1,43 @@
 {% extends 'default/base.html' %}
-
 {% block title %}{{_("Login")}} - {{super()}} {% endblock %}
-
 {% block content %}
-
-<div class="centeralign">
-<form action="" method="post" accept-charset="utf-8" id="login">
-    <div class="no">
-        <input type="hidden" name="do" value="login" />
-        <fieldset>
+<br>
+{% if logout %}
+<div id="logged_out">
+	<b>{{_("You were successfully logged out.")}}</b>
+</div>
+{% endif %}
+<br>
+<div class="login">
+    <form action="/login" method="post" class="form-horizontal">
         <legend>Login</legend>
-        <label>
-            <span>{{_("Username")}}</span>
-            <input type="text" size="20" name="username" />
-        </label>
-        <br />
-        <label>
-            <span>{{_("Password")}}</span>
-            <input type="password" size="20" name="password" />
-        </label>
-        <br />
-        <input type="submit" value="Login" class="button" />
-        </fieldset>
-    </div>
-</form>
-
+        <div class="control-group">
+            <label class="control-label" for="inputEmail">Username</label>
+            <div class="controls">
+                <input type="text" id="inputEmail" placeholder="Username" name="username">
+            </div>
+        </div>
+        <div class="control-group">
+            <label class="control-label" for="inputPassword">Password</label>
+            <div class="controls">
+                <input type="password" id="inputPassword" placeholder="Password" name="password">
+            </div>
+        </div>
+        <div class="control-group">
+            <div class="controls">
+                <label class="checkbox">
+                    <input type="checkbox"> Remember me
+                </label>
+                <button type="submit" class="btn">Login</button>
+            </div>
+        </div>
+    </form>
+</div>
+<br>
+<div style="text-align: center">
 {% if errors %}
 <p>{{_("Your username and password didn't match. Please try again.")}}</p>
   {{ _("To reset your login data or add an user run:") }} <b> python pyLoadCore.py -u</b>
 {% endif %}
-
 </div>
-<br>
-    
-{% endblock %}
+{% endblock %}
\ No newline at end of file
diff --git a/module/web/templates/default/logout.html b/module/web/templates/default/logout.html
deleted file mode 100644
index d3f07472b..000000000
--- a/module/web/templates/default/logout.html
+++ /dev/null
@@ -1,9 +0,0 @@
-{% extends 'default/base.html' %}
-
-{% block head %}
-<meta http-equiv="refresh" content="3; url=/">
-{% endblock %}
-
-{% block content %}
-<p><b>{{_("You were successfully logged out.")}}</b></p>
-{% endblock %}
\ No newline at end of file
diff --git a/module/web/templates/default/logs.html b/module/web/templates/default/logs.html
deleted file mode 100644
index d6288df0e..000000000
--- a/module/web/templates/default/logs.html
+++ /dev/null
@@ -1,41 +0,0 @@
-{% extends 'default/base.html' %}
-
-{% block title %}{{_("Logs")}} - {{super()}} {% endblock %}
-{% block subtitle %}{{_("Logs")}}{% endblock %}
-{% block head %}
-<link rel="stylesheet" type="text/css" href="/media/default/css/log.css"/>
-{% endblock %}
-
-{% block content %}
-<div style="clear: both;"></div>
-
-<div class="logpaginator"><a href="{{ "/logs/1" }}">&lt;&lt; {{_("Start")}}</a>  <a href="{{ "/logs/" + iprev|string }}">&lt; {{_("prev")}}</a>  <a href="{{ "/logs/" + inext|string }}">{{_("next")}} &gt;</a> <a href="/logs/">{{_("End")}} &gt;&gt;</a></div>
-<div class="logperpage">
-    <form id="logform1" action="" method="POST">
-        <label for="reversed">Reversed:</label>
-        <input type="checkbox" name="reversed" onchange="this.form.submit();" {% if reversed %} checked="checked" {% endif %} />&nbsp;
-        <label for="perpage">Lines per page:</label>
-        <select name="perpage" onchange="this.form.submit();">
-            {% for value in  perpage_p %}
-                <option value="{{value.0}}"{% if value.0 == perpage %} selected="selected" {% endif %}>{{value.1}}</option>
-            {% endfor %}
-        </select>
-    </form>
-</div>
-<div class="logwarn">{{warning}}</div>
-<div style="clear: both;"></div>
-<div class="logdiv">
-    <table class="logtable" cellpadding="0" cellspacing="0">
-    {% for line in log %}
-        <tr><td class="logline">{{line.line}}</td><td>{{line.date}}</td><td class="loglevel">{{line.level}}</td><td>{{line.message}}</td></tr>
-    {% endfor %}
-    </table>
-</div>
-<div class="logform">
-<form id="logform2" action="" method="POST">
-    <label for="from">Jump to time:</label><input type="text" name="from" size="15" value="{{from}}"/>
-    <input type="submit" value="ok" />
-</form>
-</div>
-<div style="clear: both; height: 10px;">&nbsp; </div>
-{% endblock %}
\ No newline at end of file
diff --git a/module/web/templates/default/pathchooser.html b/module/web/templates/default/pathchooser.html
deleted file mode 100644
index d00637055..000000000
--- a/module/web/templates/default/pathchooser.html
+++ /dev/null
@@ -1,76 +0,0 @@
-<html>
-<head>
-	<script class="javascript">
-        function chosen()
-        {
-            opener.ifield.value = document.forms[0].p.value;
-            close();
-        }
-        function exit()
-        {
-            close();
-        }
-        function setInvalid() {
-            document.forms[0].send.disabled = 'disabled';
-            document.forms[0].p.style.color = '#FF0000';
-        }
-        function setValid() {
-            document.forms[0].send.disabled = '';
-            document.forms[0].p.style.color = '#000000';
-        }
-        function setFile(file)
-        {
-            document.forms[0].p.value = file;
-            setValid();
-            
-        }
-	</script>
-	<link rel="stylesheet" type="text/css" href="/media/default/css/pathchooser.css"/>
-</head>
-<body{% if type == 'file' %}{% if not oldfile %} onload="setInvalid();"{% endif %}{% endif %}>
-<center>
-    <div id="paths">
-	<form method="get" action="?" onSubmit="chosen();" onReset="exit();">
-	    <input type="text" name="p" value="{{ oldfile|default(cwd) }}" size="60" onfocus="setValid();">
-	    <input type="submit" value="Ok" name="send">
-	</form>
-    
-    {% if type == 'folder' %}
-	<span class="path_abs_rel">{{_("Path")}}: <a href="{{ "/pathchooser" + cwd|path_make_absolute|quotepath }}"{% if absolute %} style="text-decoration: underline;"{% endif %}>{{_("absolute")}}</a> | <a href="{{ "/pathchooser/" + cwd|path_make_relative|quotepath }}"{% if not absolute %} style="text-decoration: underline;"{% endif %}>{{_("relative")}}</a></span>
-    {% else %}
-	<span class="path_abs_rel">{{_("Path")}}: <a href="{{ "/filechooser/" + cwd|path_make_absolute|quotepath }}"{% if absolute %} style="text-decoration: underline;"{% endif %}>{{_("absolute")}}</a> | <a href="{{ "/filechooser/" + cwd|path_make_relative|quotepath }}"{% if not absolute %} style="text-decoration: underline;"{% endif %}>{{_("relative")}}</a></span>
-    {% endif %}
-    </div>
-    <table border="0" cellspacing="0" cellpadding="3">
-        <tr>
-            <th>{{_("name")}}</th>
-            <th>{{_("size")}}</th>
-            <th>{{_("type")}}</th>
-            <th>{{_("last modified")}}</th>
-        </tr>
-	{% if parentdir %}
-        <tr>
-            <td colspan="4">
-                <a href="{% if type == 'folder' %}{{ "/pathchooser/" + parentdir|quotepath }}{% else %}{{ "/filechooser/" + parentdir|quotepath }}{% endif %}"><span class="parentdir">{{_("parent directory")}}</span></a>
-            </td>
-        </tr>
-	{% endif %}
-{% for file in files %}
-        <tr>
-            {% if type == 'folder' %}
-                <td class="name">{% if file.type == 'dir' %}<a href="{{ "/pathchooser/" + file.fullpath|quotepath }}" title="{{ file.fullpath }}"><span class="path_directory">{{ file.name|truncate(25) }}</span></a>{% else %}<span class="path_file" title="{{ file.fullpath }}">{{ file.name|truncate(25) }}{% endif %}</span></td>
-            {% else %}
-                <td class="name">{% if file.type == 'dir' %}<a href="{{ "/filechooser/" + file.fullpath|quotepath }}" title="{{ file.fullpath }}"><span class="file_directory">{{ file.name|truncate(25) }}</span></a>{% else %}<a href="#" onclick="setFile('{{ file.fullpath }}');" title="{{ file.fullpath }}"><span class="file_file">{{ file.name|truncate(25) }}{% endif %}</span></a></td>
-            {% endif %}
-            <td class="size">{{ file.size|float|filesizeformat }}</td>
-            <td class="type">{% if file.type == 'dir' %}directory{% else %}{{ file.ext|default("file") }}{% endif %}</td>
-            <td class="mtime">{{ file.modified|date("d.m.Y - H:i:s") }}</td>
-        <tr>
-<!--        <tr>
-            <td colspan="4">{{_("no content")}}</td>
-        </tr> -->
-{% endfor %}
-    </table>
-    </center>
-</body>
-</html>
\ No newline at end of file
diff --git a/module/web/templates/default/queue.html b/module/web/templates/default/queue.html
deleted file mode 100644
index c88fa3568..000000000
--- a/module/web/templates/default/queue.html
+++ /dev/null
@@ -1,104 +0,0 @@
-{% extends 'default/base.html' %}

-{% block head %}

-

-<script type="text/javascript" src="/media/js/package_ui.js"></script>

-

-<script type="text/javascript">

-

-document.addEvent("domready", function(){

-    var pUI = new PackageUI("url", {{ target }});

-});

-</script>

-{% endblock %}

-

-{% if target %}

-    {% set name = _("Queue") %}

-{% else %}

-    {% set name = _("Collector") %}

-{% endif %}

-

-{% block title %}{{name}} - {{super()}} {% endblock %}

-{% block subtitle %}{{name}}{% endblock %}

-

-{% block pageactions %}

-<ul id="page-actions-more">

-    <li id="del_finished"><a style="padding: 0; font-weight: bold;" href="#">{{_("Delete Finished")}}</a></li>

-    <li id="restart_failed"><a style="padding: 0; font-weight: bold;" href="#">{{_("Restart Failed")}}</a></li>

-</ul>

-{% endblock %}

-

-{% block content %}

-{% autoescape true %}

-

-<ul id="package-list" style="list-style: none; padding-left: 0; margin-top: -10px;">

-{% for package in content %}

-    <li>

-<div id="package_{{package.pid}}" class="package">

-    <div class="order" style="display: none;">{{ package.order }}</div>

-    

-    <div class="packagename" style="cursor: pointer">

-        <img class="package_drag" src="/media/default/img/folder.png" style="cursor: move; margin-bottom: -2px">

-        <span class="name">{{package.name}}</span>

-        &nbsp;&nbsp;

-        <span class="buttons" style="opacity:0">

-        <img title="{{_("Delete Package")}}" style="cursor: pointer" width="12px" height="12px" src="/media/default/img/delete.png" />

-        &nbsp;&nbsp;

-        <img title="{{_("Restart Package")}}" style="margin-left: -10px; cursor: pointer" height="12px" src="/media/default/img/arrow_refresh.png" />

-        &nbsp;&nbsp;

-        <img title="{{_("Edit Package")}}" style="margin-left: -10px; cursor: pointer" height="12px" src="/media/default/img/pencil.png" />

-        &nbsp;&nbsp;

-        <img title="{{_("Move Package")}}" style="margin-left: -10px; cursor: pointer" height="12px" src="/media/default/img/package_go.png" />

-        </span>

-    </div>

-    {% set progress = (package.linksdone * 100) / package.linkstotal %}

-

-    <div id="progress" style="border-radius: 4px; border: 1px solid #AAAAAA; width: 50%; height: 1em">

-        <div style="width: {{ progress }}%; height: 100%; background-color: #add8e6;"></div>

-        <label style="font-size: 0.8em; font-weight: bold; padding-left: 5px; position: relative; top: -17px">

-        {{ package.sizedone|formatsize }} / {{ package.sizetotal|formatsize }}</label>

-        <label style="font-size: 0.8em; font-weight: bold; padding-right: 5px ;float: right; position: relative; top: -17px">

-        {{ package.linksdone }} / {{ package.linkstotal }}</label>

-        </div>

-    <div style="clear: both; margin-bottom: -10px"></div>

-

-    <div id="children_{{package.pid}}" style="display: none;" class="children">

-    <span class="child_secrow">{{_("Folder:")}} <span class="folder">{{package.folder}}</span> | {{_("Password:")}} <span class="password">{{package.password}}</span></span>

-    <ul id="sort_children_{{package.pid}}" style="list-style: none; padding-left: 0">

-    </ul>

-    </div>

-</div>

-    </li>

-{% endfor %}

-</ul>

-{% endautoescape %}

-{% endblock %}

-

-{% block hidden %}

-<div id="pack_box" class="window_box" style="z-index: 2">

-    <form id="pack_form" action="/json/edit_package" method="POST" enctype="multipart/form-data">

-    <h1>{{_("Edit Package")}}</h1>

-    <p>{{_("Edit the package detais below.")}}</p>

-    <input name="pack_id" id="pack_id" type="hidden" value=""/>

-    <label for="pack_name">{{_("Name")}}

-    <span class="small">{{_("The name of the package.")}}</span>

-    </label>

-    <input id="pack_name" name="pack_name" type="text" size="20" />

-

-    <label for="pack_folder">{{_("Folder")}}

-    <span class="small">{{_("Name of subfolder for these downloads.")}}</span>

-    </label>

-    <input id="pack_folder" name="pack_folder" type="text" size="20" />

-

-    <label for="pack_pws">{{_("Password")}}

-    <span class="small">{{_("List of passwords used for unrar.")}}</span>

-    </label>

-    <textarea rows="3" name="pack_pws" id="pack_pws"></textarea>

-

-    <button type="submit">{{_("Submit")}}</button>

-    <button id="pack_reset" style="margin-left: 0" type="reset" >{{_("Reset")}}</button>

-    <div class="spacer"></div>

-

-    </form>

-

-</div>

-{% endblock %}
\ No newline at end of file
diff --git a/module/web/templates/default/settings.html b/module/web/templates/default/settings.html
index a4443025a..1f9be3db0 100644
--- a/module/web/templates/default/settings.html
+++ b/module/web/templates/default/settings.html
@@ -1,204 +1,133 @@
-{% extends 'default/base.html' %}
-
-{% block title %}{{ _("Config") }} - {{ super() }} {% endblock %}
-{% block subtitle %}{{ _("Config") }}{% endblock %}
-
-{% block head %}
-    <script type="text/javascript" src="/media/js/tinytab_static.js"></script>
-    <script type="text/javascript" src="/media/js/MooDropMenu_static.js"></script>
-    <script type="text/javascript" src="/media/js/settings.js"></script>
-
-{% endblock %}
-
-{% block content %}
-
-    <ul id="toptabs" class="tabs">
-            <li><a class="selected" href="#">{{ _("General") }}</a></li>
-            <li><a href="#">{{ _("Plugins") }}</a></li>
-            <li><a href="#">{{ _("Accounts") }}</a></li>
-    </ul>
-
-    <div id="tabsback" style="height: 20px; padding-left: 150px; color: white; font-weight: bold;">
-
-    </div>
-
-        <span id="tabs-body">
-            <!-- General -->
-            <span id="general" class="active tabContent">
-                <ul class="nav tabs">
-                    <li class>
-                        <a>Menu</a>
-                        <ul id="general-menu">
-                            {% for entry,name in conf.general %}
-                                <nobr>
-                                    <li id="general|{{ entry }}">{{ name }}</li>
-                                </nobr>
-                                <br>
-                            {% endfor %}
-                        </ul>
-                    </li>
-                </ul>
-
-                <form id="general_form" action="" method="POST" autocomplete="off">
-                    <span id="general_form_content">
-                    <br>
-                    <h3>&nbsp;&nbsp; {{ _("Choose a section from the menu") }}</h3>
-                    <br>
-                    </span>
-
-                  <input id="general|submit" class="styled_button" type="submit" value="{{_("Submit")}}"/>
-                </form>
-            </span>
-
-            <!-- Plugins -->
-            <span id="plugins" class="tabContent">
-                <ul class="nav tabs">
-                    <li class>
-                        <a>Menu</a>
-                        <ul id="plugin-menu">
-                            {% for entry,name in conf.plugin %}
-                                <nobr>
-                                    <li id="plugin|{{ entry }}">{{ name }}</li>
-                                </nobr>
-                                <br>
-                            {% endfor %}
-                        </ul>
-                    </li>
-                </ul>
-
-
-                 <form id="plugin_form" action="" method="POST" autocomplete="off">
-
-                     <span id="plugin_form_content">
-                    <br>
-                    <h3>&nbsp;&nbsp; {{ _("Choose a section from the menu") }}</h3>
-                    <br>
-                         </span>
-                     <input id="plugin|submit" class="styled_button" type="submit" value="{{_("Submit")}}"/>
-                </form>
-
-            </span>
-
-            <!-- Accounts -->
-            <span id="accounts" class="tabContent">
-            <form id="account_form" action="/json/update_accounts" method="POST">
-
-                        <table class="settable wide">
-
-                        <thead>
-                        <tr>
-                            <th>{{ _("Plugin") }}</th>
-                            <th>{{ _("Name") }}</th>
-                            <th>{{ _("Password") }}</th>
-                            <th>{{ _("Status") }}</th>
-                            <th>{{ _("Premium") }}</th>
-                            <th>{{ _("Valid until") }}</th>
-                            <th>{{ _("Traffic left") }}</th>
-                            <th>{{ _("Time") }}</th>
-                            <th>{{ _("Max Parallel") }}</th>
-                            <th>{{ _("Delete?") }}</th>
-                        </tr>
-                        </thead>
-
-
-                            {% for account in conf.accs %}
-                                {% set plugin = account.type %}
-                                       <tr>
-                                            <td>
-                                                <span style="padding:5px">{{ plugin }}</span>
-                                            </td>
-                                       
-                                           <td><label for="{{plugin}}|password;{{account.login}}"
-                                                      style="color:#424242;">{{ account.login }}</label></td>
-                                           <td>
-                                               <input id="{{plugin}}|password;{{account.login}}"
-                                                      name="{{plugin}}|password;{{account.login}}"
-                                                      type="password" value="{{account.password}}" size="12"/>
-                                           </td>
-                                           <td>
-                                               {% if account.valid %}
-                                                   <span style="font-weight: bold; color: #006400;">
-                                                   {{ _("valid") }}
-                                               {% else %}
-                                                   <span style="font-weight: bold; color: #8b0000;">
-                                                   {{ _("not valid") }}
-                                               {% endif %}
-                                               </span>
-                                           </td>
-                                          <td>
-                                               {% if account.premium %}
-                                                   <span style="font-weight: bold; color: #006400;">
-                                                   {{ _("yes") }}
-                                               {% else %}
-                                                   <span style="font-weight: bold; color: #8b0000;">
-                                                   {{ _("no") }}
-                                               {% endif %}
-                                               </span>
-                                           </td>
-                                           <td>
-                                   <span style="font-weight: bold;">
-                                   {{ account.validuntil }}
-                                   </span>
-                                           </td>
-                                           <td>
-                                   <span style="font-weight: bold;">
-                                   {{ account.trafficleft }}
-                                   </span>
-                                           </td>
-                                           <td>
-                                               <input id="{{plugin}}|time;{{account.login}}"
-                                                      name="{{plugin}}|time;{{account.login}}" type="text"
-                                                      size="7" value="{{account.time}}"/>
-                                           </td>
-                                           <td>
-                                               <input id="{{plugin}}|limitdl;{{account.login}}"
-                                                      name="{{plugin}}|limitdl;{{account.login}}" type="text"
-                                                      size="2" value="{{account.limitdl}}"/>
-                                           </td>
-                                           <td>
-                                               <input id="{{plugin}}|delete;{{account.login}}"
-                                                      name="{{plugin}}|delete;{{account.login}}" type="checkbox"
-                                                      value="True"/>
-                                           </td>
-                                       </tr>
-                                {% endfor %}
-                            </table>
-
-            <button id="account_submit" type="submit" class="styled_button">{{_("Submit")}}</button>
-            <button id="account_add" style="margin-left: 0" type="submit" class="styled_button">{{_("Add")}}</button>
-            </form>
-            </span>
-        </span>
-{% endblock %}
-{% block hidden %}
-<div id="account_box" class="window_box" style="z-index: 2">
-<form id="add_account_form" action="/json/add_account" method="POST" enctype="multipart/form-data">
-<h1>{{_("Add Account")}}</h1>
-<p>{{_("Enter your account data to use premium features.")}}</p>
-<label for="account_login">{{_("Login")}}
-<span class="small">{{_("Your username.")}}</span>
-</label>
-<input id="account_login" name="account_login" type="text" size="20" />
-
-<label for="account_password">{{_("Password")}}
-<span class="small">{{_("The password for this account.")}}</span>
-</label>
-<input id="account_password" name="account_password" type="password" size="20" />
-
-<label for="account_type">{{_("Type")}}
-<span class="small">{{_("Choose the hoster for your account.")}}</span>
-</label>
-    <select name=account_type id="account_type">
-        {% for type in types|sort %}
-            <option value="{{ type }}">{{ type }}</option>
-        {% endfor %}
-    </select>
-
-<button id="account_add_button" type="submit">{{_("Add")}}</button>
-<button id="account_reset" style="margin-left: 0" type="reset">{{_("Reset")}}</button>
-<div class="spacer"></div>
-
-</form>
-
-</div>
-{% endblock %}
\ No newline at end of file
+{% extends 'default/base.html' %}

+

+{% block title %}{{ _("Config") }} - {{ super() }} {% endblock %}

+{% block subtitle %}{{ _("Config") }}

+{% endblock %}

+

+{% block css %}

+    <link href="static/css/default/settings.less" rel="stylesheet/less" type="text/css" media="screen"/>

+{% endblock %}

+

+{% block require %}

+    App.initSettingsView();

+{% endblock %}

+

+{% block head %}

+    <script type="text/template" id="template-menu">

+        <%=if core%>

+            <li class="nav-header"><i class="icon-globe icon-white"></i> {{ _("General") }}</li>

+            <%=each core%>

+                <li data-name="<% this.name %>"><a href="#"><% this.label %></a></li>

+            <%/each%>

+        <%/if%>

+        <li class="divider"></li>

+        <li class="nav-header"><i class="icon-th-large icon-white"></i> {{ _("Addons") }}</li>

+        <li class="divider"></li>

+        <li class="nav-header"><i class="icon-th-list icon-white"></i> {{ _("Other") }}</li>

+    </script>

+{% endblock %}

+

+{% block content %}

+            <div class="span2">

+                <ul class="nav nav-list well settings-menu">

+                </ul>

+            </div>

+            <!-- Info Popup -->

+            <div class="modal hide fade in" id="info">

+                <div class="modal-header">

+                    <button type="button" class="close">×</button>

+                    <h3>Info Popup</h3>

+                </div>

+                <div class="modal-body">

+                    <h4>General</h4>

+

+                    <p>Duis mollis, est non commodo luctus, nisi erat porttitor ligula, eget lacinia odio sem.</p>

+

+                    <h4>And...</h4>

+

+                    <p>Cras mattis consectetur purus sit amet fermentum. Cras justo odio, dapibus ac facilisis in,

+                        egestas eget quam. Morbi leo risus, porta ac consectetur ac, vestibulum at eros.</p>

+

+                </div>

+                <div class="modal-footer">

+                    <button class="btn">Close</button>

+                </div>

+            </div>

+            <!-- End Info Popup -->

+            <div class="span10">

+                <div class="well setting-box">

+                    <form class="form-horizontal">

+                        <legend>

+                            <div class="page-header">

+                                <h1>Example Settings

+                                    <small>Subtext for header</small>

+                                    <a class="btn btn-small " href="#"><i

+                                            class="icon-question-sign"></i></a>

+                                </h1>

+                            </div>

+                        </legend>

+                        <div class="control-group">

+                            <label class="control-label">Max Parallel Downloads</label>

+

+                            <div class="controls">

+                                <input id="in_mpd" type="text" placeholder="3">

+                            </div>

+                        </div>

+                        <div class="control-group">

+                            <label class="control-label">Limit Download Speed</label>

+

+                            <div class="controls">

+                                <div class="btn-group" data-toggle="buttons-radio">

+                                    <button type="button" class="btn bnmaxspeed" id="onmaxspeed">On</button>

+                                    <button type="button" class="btn bnmaxspeed active" id="offmaxspeed">Off</button>

+                                </div>

+                                <div id="downloadspeed" style="display:none">

+                                    <label>Max Download Speed in kb/s</label>

+                                    <input type="text" placeholder="Tipp etwas ...">

+                                </div>

+                            </div>

+                        </div>

+                        <div class="control-group">

+                            <label class="control-label">Allow IPv6</label>

+

+                            <div class="controls">

+                                <div class="btn-group" data-toggle="buttons-radio">

+                                    <button type="button" class="btn bnip6" id="onip6">On</button>

+                                    <button type="button" class="btn bnip6 active" id="offip6">Off</button>

+                                </div>

+                            </div>

+                        </div>

+                        <div class="form-actions">

+                            <button type="submit" class="btn btn-primary">Änderungen Speichern</button>

+                            <button type="button" class="btn">Abbrechen</button>

+                        </div>

+                    </form>

+                </div>

+            </div>

+    <script src="static/js/libs/jquery-1.9.0.js"></script>

+    {#    <script src="static/js/libs/bootstrap-2.1.1.js"></script>#}

+    <script type="text/javascript">

+        $(".bnmaxspeed").click(function() {

+            $(".bnmaxspeed").removeClass("active");

+            $(this).toggleClass("active");

+            if ($("#onmaxspeed").hasClass("active")) {

+                $("#downloadspeed").show();

+            }

+            else {

+                $("#downloadspeed").hide();

+            }

+

+        });

+        $(".bnip6").click(function() {

+            $(".bnip6").removeClass("active");

+            $(this).toggleClass("active");

+        });

+        $('#info').modal('toggle');

+

+        $('#in_mpd').tooltip({

+            placement: 'right',

+            title: 'Gib an wie viele Downloads gleichzeitg laufen dürfen.'

+        });

+

+    </script>

+{% endblock %} 
\ No newline at end of file
diff --git a/module/web/templates/default/settings_item.html b/module/web/templates/default/settings_item.html
deleted file mode 100644
index 813383343..000000000
--- a/module/web/templates/default/settings_item.html
+++ /dev/null
@@ -1,48 +0,0 @@
-<table class="settable">
-    {% if section.outline %}
-    <tr><th colspan="2">{{ section.outline }}</th></tr>
-    {% endif %}
-    {% for okey, option in section.iteritems() %}
-        {% if okey not in ("desc","outline") %}
-            <tr>
-                <td><label for="{{skey}}|{{okey}}"
-                           style="color:#424242;">{{ option.desc }}:</label></td>
-                <td>
-                    {% if option.type == "bool" %}
-                        <select id="{{skey}}|{{okey}}" name="{{skey}}|{{okey}}">
-                            <option {% if option.value %} selected="selected"
-                                                          {% endif %}value="True">{{ _("on") }}</option>
-                            <option {% if not option.value %} selected="selected"
-                                                              {% endif %}value="False">{{ _("off") }}</option>
-                        </select>
-                        {% elif ";" in option.type %}
-                        <select id="{{skey}}|{{okey}}" name="{{skey}}|{{okey}}">
-                            {% for entry in option.list %}
-                                <option {% if option.value == entry %}
-                                        selected="selected" {% endif %}>{{ entry }}</option>
-                            {% endfor %}
-                        </select>
-                        {% elif option.type == "folder" %}
-                        <input name="{{skey}}|{{okey}}" type="text"
-                               id="{{skey}}|{{okey}}" value="{{option.value}}"/>
-                        <input name="browsebutton" type="button"
-                               onclick="ifield = document.getElementById('{{skey}}|{{okey}}'); pathchooser = window.open('{% if option.value %}{{ "/pathchooser/" + option.value|quotepath }}{% else %}{{ pathroot }}{% endif %}', 'pathchooser', 'scrollbars=yes,toolbar=no,menubar=no,statusbar=no,width=650,height=300'); pathchooser.ifield = ifield; window.ifield = ifield;"
-                               value="{{_("Browse")}}"/>
-                        {% elif option.type == "file" %}
-                        <input name="{{skey}}|{{okey}}" type="text"
-                               id="{{skey}}|{{okey}}" value="{{option.value}}"/>
-                        <input name="browsebutton" type="button"
-                               onclick="ifield = document.getElementById('{{skey}}|{{okey}}'); filechooser = window.open('{% if option.value %}{{ "/filechooser/" + option.value|quotepath }}{% else %}{{ fileroot }}{% endif %}', 'filechooser', 'scrollbars=yes,toolbar=no,menubar=no,statusbar=no,width=650,height=300'); filechooser.ifield = ifield; window.ifield = ifield;"
-                               value="{{_("Browse")}}"/>
-                        {% elif option.type == "password" %}
-                        <input id="{{skey}}|{{okey}}" name="{{skey}}|{{okey}}"
-                               type="password" value="{{option.value}}"/>
-                    {% else %}
-                        <input id="{{skey}}|{{okey}}" name="{{skey}}|{{okey}}"
-                               type="text" value="{{option.value}}"/>
-                    {% endif %}
-                </td>
-            </tr>
-        {% endif %}
-    {% endfor %}
-</table>
\ No newline at end of file
diff --git a/module/web/templates/default/setup.html b/module/web/templates/default/setup.html
index 39ef6f1e8..e5c9f4b8c 100644
--- a/module/web/templates/default/setup.html
+++ b/module/web/templates/default/setup.html
@@ -1,13 +1,16 @@
 {% extends 'default/base.html' %}
-
-{% block title %}{{ _("Setup") }} - {{ super() }} {% endblock %}
-{% block subtitle %}{{ _("Setup") }}{% endblock %}
-{% block headpanel %}Welcome to pyLoad{% endblock %}
-{% block menu %}
-    <li style="height: 25px"> <!-- Needed to get enough margin -->
-    </li>
+{% block title %}
+    {{_("Setup")}} - {{ super()}}
 {% endblock %}
 
 {% block content %}
-    Comming Soon.
+    <div class="hero-unit">
+        <h1>You did it!</h1>
+        <p>pyLoad is running and ready for configuration.</p>
+        <p>
+            <a class="btn btn-primary btn-large">
+                Go on
+            </a>
+        </p>
+    </div>
 {% endblock %}
\ No newline at end of file
diff --git a/module/web/templates/default/window.html b/module/web/templates/default/window.html
deleted file mode 100644
index b61fa7149..000000000
--- a/module/web/templates/default/window.html
+++ /dev/null
@@ -1,46 +0,0 @@
-<iframe id="upload_target" name="upload_target" src="" style="display: none; width:0;height:0"></iframe>

-

-<div id="add_box" class="window_box">

-<form id="add_form" action="/json/add_package" method="POST" enctype="multipart/form-data">

-<h1>{{_("Add Package")}}</h1>

-<p>{{_("Paste your links or upload a container.")}}</p>

-<label for="add_name">{{_("Name")}}

-<span class="small">{{_("The name of the new package.")}}</span>

-</label>

-<input id="add_name" name="add_name" type="text" size="20" />

-

-<label for="add_links">{{_("Links")}}

-<span class="small">{{_("Paste your links here or any text and press the filter button.")}}</span>

-<span class="small"> {{ _("Filter urls") }}

-<img alt="URIParsing" Title="Parse Uri" src="/media/default/img/parseUri.png" style="cursor:pointer; vertical-align: text-bottom;" onclick="parseUri()"/>

-</span>

-

-</label>

-<textarea rows="5" name="add_links" id="add_links"></textarea>

-

-<label for="add_password">{{_("Password")}}

-    <span class="small">{{_("Password for RAR-Archive")}}</span>

-</label>

-<input id="add_password" name="add_password" type="text" size="20">

-

-<label>{{_("File")}}

-<span class="small">{{_("Upload a container.")}}</span>

-</label>

-<input type="file" name="add_file" id="add_file"/>

-

-<label for="add_dest">{{_("Destination")}}

-</label>

-<span class="cont">

-    {{_("Queue")}}

-    <input type="radio" name="add_dest" id="add_dest" value="1" checked="checked"/>

-    {{_("Collector")}}

-    <input type="radio" name="add_dest" id="add_dest2" value="0"/>

-</span>

-

-<button type="submit">{{_("Add Package")}}</button>

-<button id="add_reset" style="margin-left:0;" type="reset">{{_("Reset")}}</button>

-<div class="spacer"></div>

-

-</form>

-

-</div>
\ No newline at end of file
diff --git a/module/web/templates/mobile/base.html b/module/web/templates/mobile/base.html
new file mode 100644
index 000000000..c40d1449b
--- /dev/null
+++ b/module/web/templates/mobile/base.html
@@ -0,0 +1,84 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1" />
+        <title>{% block title %}pyLoad {{ _("Webinterface") }}{% endblock %}</title>
+        <meta name="HandheldFriendly" content="True">
+        <meta http-equiv="cleartype" content="on">
+
+        <link rel="stylesheet" href="/static/css/mobile/jquery.mobile-1.1.1.min.css" />
+        <link rel="stylesheet" href="/static/css/mobile/my.css" type="text/css" />
+        <link rel="stylesheet" href="/static/css/font.css"/>
+        
+
+        <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js"></script>
+        <script src="https://ajax.aspnetcdn.com/ajax/jquery.mobile/1.1.1/jquery.mobile-1.1.1.min.js"></script>
+        <script src="my.js"></script>
+
+
+        <script type="text/javascript" data-main="static/js/default" src="/static/js/libs/require-2.1.2.js"></script>
+        <script>
+            require(['mobile'], function(App) {
+                App.init();
+                {% block require %}{% endblock %}
+            });
+         </script>
+
+
+        {% block head %}{% endblock %}
+    </head>
+    <body>
+        <!-- Home -->
+        <div data-role="page" id="page1">
+            <div data-theme="a" data-role="header">
+                {% block header %}{% endblock %}
+                {% if user %}
+                <!-- Navbar -->
+                <div data-role="navbar" data-iconpos="bottom">
+                    <ul>
+                        <li>
+                            <a href="#page1" data-theme="" data-icon="back">
+                                Back
+                            </a>
+                        </li>
+                        <li>
+                            <a href="#page1" data-theme="" data-icon="home" class="ui-btn-active ui-state-persist">
+                                Home
+                            </a>
+                        </li>
+                        <li>
+                            <a href="#page1" data-theme="" data-icon="plus">
+                                Add
+                            </a>
+                        </li>
+                        <li>
+                            <a href="#page1" data-theme="" data-icon="gear">
+                                Settings
+                            </a>
+                        </li>
+			{% block navbar %}{% endblock %}
+                    </ul>
+                </div>
+                {% endif %}
+
+            </div>
+            <div data-role="content">
+		{% block content %}{% endblock %}
+            </div>
+            <div data-theme="a" data-role="footer" data-position="fixed">
+		{% block footer %}{% endblock %}
+                <div>
+                    <a data-role="button" data-transition="none" href="/toggle_mobile" class="ui-btn-left">
+                        {{ _("Desktop Version") }}
+                    </a>
+                    <a data-role="button" data-transition="none" href="http://pyload.org/" class="ui-btn-right">
+                        {{ _("Pyload") }}
+                    </a>
+                </div>
+
+            </div>
+        </div>
+	{% block pages %}{% endblock %}
+    </body>
+</html>
diff --git a/module/web/templates/mobile/login.html b/module/web/templates/mobile/login.html
new file mode 100644
index 000000000..5821cc0c8
--- /dev/null
+++ b/module/web/templates/mobile/login.html
@@ -0,0 +1,31 @@
+{% extends 'mobile/base.html' %}
+{% block title %}{{_("Login")}} - {{super()}} {% endblock %}
+
+{% block header %}
+	<h2>
+		PyLoad Login
+	</h2>
+{% endblock %}
+
+{% block content %}
+                <form action="/login" method="POST" data-ajax="false">
+                    <div data-role="fieldcontain">
+                        <fieldset data-role="controlgroup">
+                            <label for="username">
+                                Username
+                            </label>
+                            <input name="username" id="username" placeholder="username" value="" type="text" />
+                        </fieldset>
+                    </div>
+                    <div data-role="fieldcontain">
+                        <fieldset data-role="controlgroup">
+                            <label for="password">
+                                Password
+                            </label>
+                            <input name="password" id="password" placeholder="password" value="" type="password" />
+                        </fieldset>
+                    </div>
+                    <input id="submit" type="submit" data-theme="a" data-icon="forward" data-iconpos="left" value="Login" />
+                </form>
+{% endblock %}
+
diff --git a/module/web/utils.py b/module/web/utils.py
index a89c87558..cbe8f3071 100644
--- a/module/web/utils.py
+++ b/module/web/utils.py
@@ -1,115 +1,81 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-"""
-    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.
+import re
+from bottle import request, HTTPError, redirect
 
-    You should have received a copy of the GNU General Public License
-    along with this plrogram; if not, see <http://www.gnu.org/licenses/>.
-
-    @author: RaNaN
-"""
-from bottle import request, HTTPError, redirect, ServerAdapter
-
-from webinterface import env, TEMPLATE
-
-from module.Api import has_permission, PERMS, ROLE
+from webinterface import env, TEMPLATE, PYLOAD, SETUP
 
+# TODO: useful but needs a rewrite, too
 def render_to_response(name, args={}, proc=[]):
     for p in proc:
         args.update(p())
-
-    t = env.get_template(TEMPLATE + "/" + name)
+    if is_mobile():
+        t = env.get_or_select_template(("mobile/" + name,))
+    else:
+        t = env.get_or_select_template((TEMPLATE + "/" + name, "default/" + name, name))
     return t.render(**args)
 
 
-def parse_permissions(session):
-    perms = dict([(x, False) for x in dir(PERMS) if not x.startswith("_")])
-    perms["ADMIN"] = False
-    perms["is_admin"] = False
-
-    if not session.get("authenticated", False):
-        return perms
-
-    if session.get("role") == ROLE.ADMIN:
-        for k in perms.iterkeys():
-            perms[k] = True
-
-    elif session.get("perms"):
-        p = session.get("perms")
-        get_permission(perms, p)
-
-    return perms
-
-
-def permlist():
-    return [x for x in dir(PERMS) if not x.startswith("_") and x != "ALL"]
-
-
-def get_permission(perms, p):
-    """Returns a dict with permission key
-
-    :param perms: dictionary
-    :param p:  bits
-    """
-    for name in permlist():
-        perms[name] = has_permission(p, getattr(PERMS, name))
-
-
-def set_permission(perms):
-    """generates permission bits from dictionary
-
-    :param perms: dict
-    """
-    permission = 0
-    for name in dir(PERMS):
-        if name.startswith("_"): continue
-
-        if name in perms and perms[name]:
-            permission |= getattr(PERMS, name)
-
-    return permission
-
-
-def set_session(request, info):
+def set_session(request, user):
     s = request.environ.get('beaker.session')
-    s["authenticated"] = True
-    s["user_id"] = info["id"]
-    s["name"] = info["name"]
-    s["role"] = info["role"]
-    s["perms"] = info["permission"]
-    s["template"] = info["template"]
+    s["uid"] = user.uid
     s.save()
-
     return s
 
-
-def parse_userdata(session):
-    return {"name": session.get("name", "Anonymous"),
-            "is_admin": True if session.get("role", 1) == 0 else False,
-            "is_authenticated": session.get("authenticated", False)}
+def get_user_api(s):
+    if s:
+        uid = s.get("uid", None)
+        if (uid is not None) and (PYLOAD is not None):
+            return PYLOAD.withUserContext(uid)
+    return None
+
+def is_mobile():
+    if request.get_cookie("mobile"):
+        if request.get_cookie("mobile") == "True":
+            return True
+        else:
+            return False
+    mobile_ua = request.headers.get('User-Agent', '').lower()
+    if mobile_ua.find('opera mini') > 0:
+        return True
+    if mobile_ua.find('windows') > 0:
+        return False
+    if request.headers.get('Accept', '').lower().find('application/vnd.wap.xhtml+xml') > 0:
+        return True
+    if re.search('(up.browser|up.link|mmp|symbian|smartphone|midp|wap|phone|android)', mobile_ua) is not None:
+        return True
+    mobile_ua = mobile_ua[:4]
+    mobile_agents = ['w3c ','acs-','alav','alca','amoi','audi','avan','benq','bird','blac','blaz','brew','cell','cldc','cmd-',
+                     'dang','doco','eric','hipt','inno','ipaq','java','jigs','kddi','keji','leno','lg-c','lg-d','lg-g','lge-',
+                     'maui','maxo','midp','mits','mmef','mobi','mot-','moto','mwbp','nec-','newt','noki','palm','pana','pant',
+                     'phil','play','port','prox','qwap','sage','sams','sany','sch-','sec-','send','seri','sgh-','shar','sie-',
+                     'siem','smal','smar','sony','sph-','symb','t-mo','teli','tim-','tosh','tsm-','upg1','upsi','vk-v','voda',
+                     'wap-','wapa','wapi','wapp','wapr','webc','winw','winw','xda ','xda-']
+    if mobile_ua in mobile_agents:
+        return True
+    return False
 
 
 def login_required(perm=None):
     def _dec(func):
         def _view(*args, **kwargs):
+
+            # In case of setup, no login methods can be accessed
+            if SETUP is not None:
+                redirect("/setup")
+
             s = request.environ.get('beaker.session')
-            if s.get("name", None) and s.get("authenticated", False):
+            api = get_user_api(s)
+            if api is not None:
                 if perm:
-                    perms = parse_permissions(s)
-                    if perm not in perms or not perms[perm]:
+                    if api.user.hasPermission(perm):
                         if request.headers.get('X-Requested-With') == 'XMLHttpRequest':
                             return HTTPError(403, "Forbidden")
                         else:
                             return redirect("/nopermission")
 
+                kwargs["api"] = api
                 return func(*args, **kwargs)
             else:
                 if request.headers.get('X-Requested-With') == 'XMLHttpRequest':
@@ -120,18 +86,3 @@ def login_required(perm=None):
         return _view
 
     return _dec
-
-
-def toDict(obj):
-    ret = {}
-    for att in obj.__slots__:
-        ret[att] = getattr(obj, att)
-    return ret
-
-
-class CherryPyWSGI(ServerAdapter):
-    def run(self, handler):
-        from wsgiserver import CherryPyWSGIServer
-
-        server = CherryPyWSGIServer((self.host, self.port), handler)
-        server.start()
diff --git a/module/web/webinterface.py b/module/web/webinterface.py
index ec8b2e56c..f18157cd7 100644
--- a/module/web/webinterface.py
+++ b/module/web/webinterface.py
@@ -1,157 +1,133 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""
-    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/>.
-
-    @author: RaNaN
-"""
-
-import sys
-import module.common.pylgettext as gettext
-
-import os
-from os.path import join, abspath, dirname, exists
-from os import makedirs
-
-PROJECT_DIR = abspath(dirname(__file__))
-PYLOAD_DIR = abspath(join(PROJECT_DIR, "..", ".."))
-
-sys.path.append(PYLOAD_DIR)
-
-from module import InitHomeDir
-from module.utils import decode, formatSize
-
-import bottle
-from bottle import run, app
-
-from jinja2 import Environment, FileSystemLoader, PrefixLoader, FileSystemBytecodeCache
-from middlewares import StripPathMiddleware, GZipMiddleWare, PrefixMiddleware
-
-SETUP = None
-PYLOAD = None
-
-from module.web import ServerThread
-
-if not ServerThread.core:
-    if ServerThread.setup:
-        SETUP = ServerThread.setup
-        config = SETUP.config
-    else:
-        raise Exception("Could not access pyLoad Core")
-else:
-    PYLOAD = ServerThread.core.api
-    config = ServerThread.core.config
-
-from module.common.JsEngine import JsEngine
-
-JS = JsEngine()
-
-TEMPLATE = config.get('webinterface', 'template')
-DL_ROOT = config.get('general', 'download_folder')
-LOG_ROOT = config.get('log', 'log_folder')
-PREFIX = config.get('webinterface', 'prefix')
-
-if PREFIX:
-    PREFIX = PREFIX.rstrip("/")
-    if not PREFIX.startswith("/"):
-        PREFIX = "/" + PREFIX
-
-DEBUG = config.get("general", "debug_mode") or "-d" in sys.argv or "--debug" in sys.argv
-bottle.debug(DEBUG)
-
-cache = join("tmp", "jinja_cache")
-if not exists(cache):
-    makedirs(cache)
-
-bcc = FileSystemBytecodeCache(cache, '%s.cache')
-loader = PrefixLoader({
-    "default": FileSystemLoader(join(PROJECT_DIR, "templates", "default")),
-    'js': FileSystemLoader(join(PROJECT_DIR, 'media', 'js'))
-})
-
-env = Environment(loader=loader, extensions=['jinja2.ext.i18n', 'jinja2.ext.autoescape'], trim_blocks=True, auto_reload=False,
-    bytecode_cache=bcc)
-
-from filters import quotepath, path_make_relative, path_make_absolute, truncate, date
-
-env.filters["quotepath"] = quotepath
-env.filters["truncate"] = truncate
-env.filters["date"] = date
-env.filters["path_make_relative"] = path_make_relative
-env.filters["path_make_absolute"] = path_make_absolute
-env.filters["decode"] = decode
-env.filters["type"] = lambda x: str(type(x))
-env.filters["formatsize"] = formatSize
-env.filters["getitem"] = lambda x, y: x.__getitem__(y)
-if PREFIX:
-    env.filters["url"] = lambda x: x
-else:
-    env.filters["url"] = lambda x: PREFIX + x if x.startswith("/") else x
-
-gettext.setpaths([join(os.sep, "usr", "share", "pyload", "locale"), None])
-translation = gettext.translation("django", join(PYLOAD_DIR, "locale"),
-    languages=[config.get("general", "language"), "en"],fallback=True)
-translation.install(True)
-env.install_gettext_translations(translation)
-
-from beaker.middleware import SessionMiddleware
-
-session_opts = {
-    'session.type': 'file',
-    'session.cookie_expires': False,
-    'session.data_dir': './tmp',
-    'session.auto': False
-}
-
-web = StripPathMiddleware(SessionMiddleware(app(), session_opts))
-web = GZipMiddleWare(web)
-
-if PREFIX:
-    web = PrefixMiddleware(web, prefix=PREFIX)
-
-import pyload_app
-import json_app
-import cnl_app
-import api_app
-
-def run_simple(host="0.0.0.0", port="8000"):
-    run(app=web, host=host, port=port, quiet=True)
-
-
-def run_lightweight(host="0.0.0.0", port="8000"):
-    run(app=web, host=host, port=port, quiet=True, server="bjoern")
-
-
-def run_threaded(host="0.0.0.0", port="8000", theads=3, cert="", key=""):
-    from wsgiserver import CherryPyWSGIServer
-
-    if cert and key:
-        CherryPyWSGIServer.ssl_certificate = cert
-        CherryPyWSGIServer.ssl_private_key = key
-
-    CherryPyWSGIServer.numthreads = theads
-
-    from utils import CherryPyWSGI
-
-    run(app=web, host=host, port=port, server=CherryPyWSGI, quiet=True)
-
-
-def run_fcgi(host="0.0.0.0", port="8000"):
-    from bottle import FlupFCGIServer
-
-    run(app=web, host=host, port=port, server=FlupFCGIServer, quiet=True)
-
-
-if __name__ == "__main__":
-    run(app=web, port=8001)
+#!/usr/bin/env python

+# -*- coding: utf-8 -*-

+"""

+    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/>.

+

+    @author: RaNaN

+"""

+

+import sys

+import module.common.pylgettext as gettext

+

+import os

+from os.path import join, abspath, dirname, exists

+from os import makedirs

+

+PROJECT_DIR = abspath(dirname(__file__))

+PYLOAD_DIR = abspath(join(PROJECT_DIR, "..", ".."))

+

+sys.path.append(PYLOAD_DIR)

+

+from module import InitHomeDir

+from module.utils import format_size

+

+import bottle

+from bottle import run, app

+

+from jinja2 import Environment, FileSystemLoader, PrefixLoader, FileSystemBytecodeCache

+from middlewares import StripPathMiddleware, GZipMiddleWare, PrefixMiddleware

+

+SETUP = None

+PYLOAD = None

+

+from module.web import ServerThread

+

+if not ServerThread.core:

+    if ServerThread.setup:

+        SETUP = ServerThread.setup

+        config = SETUP.config

+    else:

+        raise Exception("Could not access pyLoad Core")

+else:

+    PYLOAD = ServerThread.core.api

+    config = ServerThread.core.config

+

+from module.common.JsEngine import JsEngine

+

+JS = JsEngine()

+

+TEMPLATE = config.get('webinterface', 'template')

+DL_ROOT = config.get('general', 'download_folder')

+LOG_ROOT = config.get('log', 'log_folder')

+PREFIX = config.get('webinterface', 'prefix')

+

+if PREFIX:

+    PREFIX = PREFIX.rstrip("/")

+    if PREFIX and not PREFIX.startswith("/"):

+        PREFIX = "/" + PREFIX

+

+DEBUG = config.get("general", "debug_mode") or "-d" in sys.argv or "--debug" in sys.argv

+bottle.debug(DEBUG)

+

+cache = join("tmp", "jinja_cache")

+if not exists(cache):

+    makedirs(cache)

+

+bcc = FileSystemBytecodeCache(cache, '%s.cache')

+loader = PrefixLoader({

+    "default": FileSystemLoader(join(PROJECT_DIR, "templates", "default")),

+    "mobile": FileSystemLoader(join(PROJECT_DIR, "templates", "mobile")),

+    'js': FileSystemLoader(join(PROJECT_DIR, 'media', 'js'))

+})

+

+env = Environment(loader=loader, extensions=['jinja2.ext.i18n', 'jinja2.ext.autoescape'], trim_blocks=True, auto_reload=True,

+    bytecode_cache=bcc)

+

+# Filter

+

+env.filters["type"] = lambda x: str(type(x))

+env.filters["formatsize"] = format_size

+env.filters["getitem"] = lambda x, y: x.__getitem__(y)

+if not PREFIX:

+    env.filters["url"] = lambda x: x

+else:

+    env.filters["url"] = lambda x: PREFIX + x if x.startswith("/") else x

+

+# Locale

+

+gettext.setpaths([join(os.sep, "usr", "share", "pyload", "locale"), None])

+translation = gettext.translation("django", join(PYLOAD_DIR, "locale"),

+    languages=[config.get("general", "language"), "en"],fallback=True)

+translation.install(True)

+env.install_gettext_translations(translation)

+

+# Middlewares

+

+from beaker.middleware import SessionMiddleware

+

+session_opts = {

+    'session.type': 'file',

+    'session.cookie_expires': False,

+    'session.data_dir': './tmp',

+    'session.auto': False

+}

+

+session = SessionMiddleware(app(), session_opts)

+web = StripPathMiddleware(session)

+web = GZipMiddleWare(web)

+

+if PREFIX:

+    web = PrefixMiddleware(web, prefix=PREFIX)

+

+import pyload_app

+import setup_app

+import cnl_app

+import api_app

+

+# Server Adapter

+def run_server(host, port, server):

+    run(app=web, host=host, port=port, quiet=True, server=server)

+

+if __name__ == "__main__":

+    run(app=web, port=8001)