From 01cbc0e985413ab16b09f0912f81da775debfe7d Mon Sep 17 00:00:00 2001
From: Vishal Goel <vishal.goel@saviantconsulting.com>
Date: Fri, 17 Jun 2022 13:06:07 +0530
Subject: [PATCH 1/4] Fieldbus part 1

---
 examples/example_fieldbus.py    | 160 +++++++++++++
 functionaltest/test_fieldbus.py | 261 +++++++++++++++++++++
 src/ghsapi/fieldbus_api.py      | 245 ++++++++++++++++++++
 src/ghsapi/ghsapi.py            | 120 ++++++++++
 unittest/test_fieldbus_api.py   | 389 ++++++++++++++++++++++++++++++++
 unittest/test_suite.py          |   3 +
 6 files changed, 1178 insertions(+)
 create mode 100644 examples/example_fieldbus.py
 create mode 100644 functionaltest/test_fieldbus.py
 create mode 100644 src/ghsapi/fieldbus_api.py
 create mode 100644 unittest/test_fieldbus_api.py

diff --git a/examples/example_fieldbus.py b/examples/example_fieldbus.py
new file mode 100644
index 0000000..66a3df9
--- /dev/null
+++ b/examples/example_fieldbus.py
@@ -0,0 +1,160 @@
+# Copyright (C) 2022 Hottinger Bruel and Kjaer Benelux B.V.
+# Schutweg 15a
+# 5145 NP Waalwijk
+# The Netherlands
+# http://www.hbm.com
+
+# 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.
+
+"""The GEN DAQ FieldBus API code examples.
+
+This is to help you get started with FieldBus API"""
+
+import os
+import sys
+import time
+
+currentdir = os.path.dirname(os.path.realpath(__file__))
+parentdir = os.path.dirname(currentdir)
+
+sys.path.append(parentdir)
+
+from src.ghsapi import ghsapi
+
+IP_ADDRESS = "localhost"
+PORT_NO = 8006
+
+
+def main():
+    """Code example to use FieldBus API."""
+
+    update_rate = 1
+    gen = ghsapi.GHS()
+
+    # Connect to the mainframe "localhost" is also possible.
+    return_var = gen.ghs_connect(IP_ADDRESS, PORT_NO)
+    if return_var == "APIMismatch":
+        print("Failed on GHSConnect. Client API version mismatch")
+        sys.exit()
+    if return_var != "OK":
+        print(f"Failed on GHSConnect. Return Status: {return_var}")
+        sys.exit()
+    print(f"GHSConnect - Return Status: {return_var}")
+
+    # Open a new connection for the field bus data
+    (
+        return_var,
+        update_rate,
+        data_count,
+    ) = gen.ghs_initiate_fieldbus_data_transfer(update_rate)
+    if return_var != "OK":
+        print(
+            f"Failed on GHSInitiateFieldBusDataTransfer. Return Status: {return_var}"
+        )
+        sys.exit()
+    print(
+        f"GHSInitiateFieldBusDataTransfer - Return Status: {return_var}\
+        \nUpdate rate : {update_rate}\
+        Data count: {data_count}"
+    )
+
+    # Closes the socket dedicated for the field bus data and stops transfering data.
+    return_var = gen.ghs_stop_fieldbus_data_transfer()
+    if return_var != "OK":
+        print(
+            f"Failed on GHSStopFieldBusDataTransfer. Return Status: {return_var}"
+        )
+        sys.exit()
+    print(f"GHSStopFieldBusDataTransfer - Return Status: {return_var}")
+
+    # Gets the number of data that are configured to be sent through the field bus
+    return_var, data_count = gen.ghs_get_fieldbus_data_count()
+    if return_var != "OK":
+        print(
+            f"Failed on GHSGetFieldBusDataCount. Return Status: {return_var}"
+        )
+        sys.exit()
+    print(
+        f"GHSGetFieldBusDataCount - Return Status: {return_var}\
+        \nData count: {data_count}"
+    )
+
+    # Gets the name of specific field bus data value, by giving the index of the data value
+    for data_index in range(data_count):
+
+        (
+            return_var,
+            data_name,
+            data_unit,
+        ) = gen.ghs_get_fieldbus_data_name_and_unit(data_index)
+        if return_var != "OK":
+            print(
+                f"Failed on GHSGetFieldBusDataNameAndUnit for index {data_index + 1}. Return Status: {return_var}"
+            )
+            sys.exit()
+        print(
+            f"GHSGetFieldBusDataNameAndUnit - Return Status: {return_var}\
+            \nData index : {data_index}\
+            \nData name : {data_name}\
+            Data unit: {data_unit}"
+        )
+
+    # Start preview mode
+    return_var = gen.ghs_start_preview()
+    if return_var != "OK":
+        print(f"Failed on GHSStartPreview. Return Status: {return_var}")
+        sys.exit()
+    print(f"GHSStartPreview - Return Status: {return_var}")
+    time.sleep(1)
+
+    # Request a single snapshot of the field bus data.
+    (
+        return_var,
+        time_stamp,
+        data_count,
+        data,
+    ) = gen.ghs_request_fieldbus_snapshot()
+    if return_var != "OK":
+        print(
+            f"Failed on GHSRequestFieldBusSnapshot. Return Status: {return_var}"
+        )
+        sys.exit()
+    print(
+        f"GHSRequestFieldBusSnapshot - Return Status: {return_var}\
+        \nTimestamp : {time_stamp}\
+        \nData count : {data_count}\
+        Data: {data}"
+    )
+
+    # Stop preview mode
+    return_var = gen.ghs_stop_preview()
+    if return_var != "OK":
+        print(f"Failed on GHSStopPreview. Return Status: {return_var}")
+        sys.exit()
+    print(f"GHSStopPreview - Return Status: {return_var}")
+
+    return_var = gen.ghs_disconnect()
+    if return_var != "OK":
+        print(f"Failed on GHSDisconnect. Return Status: {return_var}")
+        sys.exit()
+    print(f"GHSDisconnect - Return Status: {return_var}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/functionaltest/test_fieldbus.py b/functionaltest/test_fieldbus.py
new file mode 100644
index 0000000..bdd79c4
--- /dev/null
+++ b/functionaltest/test_fieldbus.py
@@ -0,0 +1,261 @@
+# Copyright (C) 2022 Hottinger Bruel and Kjaer Benelux B.V.
+# Schutweg 15a
+# 5145 NP Waalwijk
+# The Netherlands
+# http://www.hbm.com
+
+# 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.
+
+"""FieldBus API functional test."""
+
+import os
+import sys
+import unittest
+
+import HtmlTestRunner
+
+currentdir = os.path.dirname(os.path.realpath(__file__))
+parentdir = os.path.dirname(currentdir)
+
+sys.path.append(parentdir)
+
+from src.ghsapi import ghsapi
+
+IP_ADDRESS = "localhost"
+PORT_NO = 8006
+
+
+class TestFieldbus(unittest.TestCase):
+    """FieldBus API functional test."""
+
+    gen = ghsapi.GHS()
+
+    @classmethod
+    def setUpClass(cls):
+        # run connect api at start of test file
+        cls.gen.ghs_connect(IP_ADDRESS, PORT_NO)
+
+    @classmethod
+    def tearDownClass(cls):
+        # run disconnect api at end of test file
+        cls.gen.ghs_disconnect()
+
+    def setUp(self):
+        # runs before each test
+        pass
+
+    def tearDown(self):
+        # runs after each test
+        self.gen.ghs_stop_fieldbus_data_transfer()
+        self.gen.ghs_stop_preview()
+
+    def test_initiate_fieldbus_data_transfer(self):
+        """Test initiate fieldbus"""
+
+        (
+            return_var,
+            update_rate,
+            data_count,
+        ) = self.gen.ghs_initiate_fieldbus_data_transfer(1)
+        self.assertEqual(
+            isinstance(update_rate, int),
+            True,
+            "Failed on get update rate.",
+        )
+        self.assertEqual(
+            update_rate,
+            1,
+            "Failed to set update rate.",
+        )
+        self.assertEqual(
+            isinstance(data_count, int),
+            True,
+            "Failed on get data count.",
+        )
+        self.assertEqual(
+            return_var,
+            "OK",
+            "Failed on initiate fieldbus.",
+        )
+
+    def test_double_initiate_fieldbus_data_transfer(self):
+        """Test initiate fieldbus when already initiated"""
+
+        self.gen.ghs_initiate_fieldbus_data_transfer(1)
+
+        (
+            return_var,
+            update_rate,
+            data_count,
+        ) = self.gen.ghs_initiate_fieldbus_data_transfer(1)
+        self.assertEqual(
+            return_var,
+            "FieldBusAlready_Enabled",
+            "Failed on initiate fieldbus when already initiated",
+        )
+
+    def test_get_fieldbus_data_count(self):
+        """Test to get fieldbus data count"""
+
+        (
+            return_var,
+            data_count,
+        ) = self.gen.ghs_get_fieldbus_data_count()
+        self.assertEqual(
+            isinstance(data_count, int),
+            True,
+            "Failed on get data count.",
+        )
+        self.assertEqual(
+            return_var,
+            "OK",
+            "Failed on get data count.",
+        )
+
+    def test_get_fieldbus_data_name_and_unit(self):
+        """Test to get fieldbus data name and unit"""
+
+        (
+            return_var,
+            data_name,
+            data_unit,
+        ) = self.gen.ghs_get_fieldbus_data_name_and_unit(1)
+        self.assertEqual(
+            isinstance(data_name, str),
+            True,
+            "Failed on get data name.",
+        )
+        self.assertEqual(
+            isinstance(data_unit, str),
+            True,
+            "Failed on get data unit.",
+        )
+        self.assertEqual(
+            return_var,
+            "OK",
+            "Failed on get data name and unit.",
+        )
+
+    def test_get_invalid_fieldbus_data_name_and_unit(self):
+        """Test to get invalid fieldbus data name and unit"""
+
+        (
+            return_var,
+            data_name,
+            data_unit,
+        ) = self.gen.ghs_get_fieldbus_data_name_and_unit(20)
+        self.assertEqual(
+            return_var,
+            "InvalidChannelIndex",
+            "Failed on get invalid data name and unit.",
+        )
+
+    def test_request_fieldbus_snapshot(self):
+        """Test to request fieldbus snapshot"""
+
+        return_var = self.gen.ghs_start_preview()
+        self.assertEqual(
+            return_var,
+            "OK",
+            "Failed on start preview.",
+        )
+
+        (
+            return_var,
+            time_stamp,
+            data_count,
+            data,
+        ) = self.gen.ghs_request_fieldbus_snapshot()
+        self.assertEqual(
+            isinstance(time_stamp, float),
+            True,
+            "Failed on get time stamp.",
+        )
+        self.assertEqual(
+            isinstance(data_count, int),
+            True,
+            "Failed on get data count.",
+        )
+        self.assertEqual(
+            isinstance(data, list),
+            True,
+            "Failed on get data.",
+        )
+        self.assertEqual(
+            return_var,
+            "OK",
+            "Failed on request fieldbus snapshot.",
+        )
+
+    def test_request_fieldbus_snapshot_not_acquiring(self):
+        """Test to request fieldbus snapshot when not acquiring"""
+        (
+            return_var,
+            time_stamp,
+            data_count,
+            data,
+        ) = self.gen.ghs_request_fieldbus_snapshot()
+        self.assertEqual(
+            return_var,
+            "SystemNotRecording",
+            "Failed on request fieldbus snapshot when not acquiring.",
+        )
+
+    def test_request_fieldbus_snapshot_when_enabled(self):
+        """Test to request fieldbus snapshot when fieldbus is enabled"""
+
+        (
+            return_var,
+            update_rate,
+            data_count,
+        ) = self.gen.ghs_initiate_fieldbus_data_transfer(1)
+        self.assertEqual(
+            return_var,
+            "OK",
+            "Failed on initiate fieldbus.",
+        )
+
+        return_var = self.gen.ghs_start_preview()
+        self.assertEqual(
+            return_var,
+            "OK",
+            "Failed on start preview.",
+        )
+
+        (
+            return_var,
+            time_stamp,
+            data_count,
+            data,
+        ) = self.gen.ghs_request_fieldbus_snapshot()
+        self.assertEqual(
+            return_var,
+            "FieldBusAlready_Enabled",
+            "Failed on request fieldbus snapshot when fieldbus is enabled.",
+        )
+
+
+if __name__ == "__main__":
+    unittest.main(
+        testRunner=HtmlTestRunner.HTMLTestRunner(
+            open_in_browser=True,
+            report_name="FieldBus API Functional Test Report",
+            report_title="FieldBus API Functional Test Report",
+        )
+    )
diff --git a/src/ghsapi/fieldbus_api.py b/src/ghsapi/fieldbus_api.py
new file mode 100644
index 0000000..1eeb8e2
--- /dev/null
+++ b/src/ghsapi/fieldbus_api.py
@@ -0,0 +1,245 @@
+# Copyright (C) 2022 Hottinger Bruel and Kjaer Benelux B.V.
+# Schutweg 15a
+# 5145 NP Waalwijk
+# The Netherlands
+# http://www.hbm.com
+
+# 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.
+
+"""FieldBus module interface."""
+
+from .connection import ConnectionHandler
+from .ghsapi_states import RETURN_KEY, GHSReturnValue, to_string
+
+
+def initiate_fieldbus_data_transfer(
+    con_handle: ConnectionHandler, update_rate: int
+) -> tuple[str, int | None, int | None]:
+    """Opens a new connection for the field bus data, and waits for client to
+    connect. Once the client connects, if the acquisition state is active,
+    data is sent to the client. Otherwise nothing is sent.
+
+    If no formulas are present then you get error code back:
+    GHSReturnValue_FieldBusError_NotConfigured if the field bus is already
+    initiated then an error code is returned:
+    GHSReturnValue_FieldBusError_FieldBusEnabled. To change the update rate
+    the field bus needs to be stoped and inititate again with a new update
+    rate.
+
+    Args:
+        con_handle: The unique connection identifier returned by GHSConnect
+        update_rate: (in Hz) The update rate should be a part of the list
+        containing the supported update rates.If the update rate selected by
+        the user is not supported, the mainframe will adjust the update rate,
+        based on a minimum distance from the supported rates and returns back
+        to the client.
+
+    Returns:
+       Tuple with status, update rate and data count.
+    """
+
+    if not update_rate:
+        return "NullPtrArgument", None, None
+
+    initiate_fieldbus_dict = {
+        "UpdateRate": update_rate,
+    }
+
+    response_json = con_handle.send_request_wait_response(
+        "InitiateFieldBusDataTransfer", initiate_fieldbus_dict
+    )
+
+    if (
+        not any(
+            key in response_json
+            for key in [
+                "FieldBusPort",
+                "BufferDepth",
+                "UpdateRate",
+                "DataCount",
+            ]
+        )
+    ) or (response_json[RETURN_KEY] != GHSReturnValue["OK"]):
+        return (
+            to_string(response_json[RETURN_KEY], GHSReturnValue),
+            None,
+            None,
+        )
+
+    return (
+        to_string(response_json[RETURN_KEY], GHSReturnValue),
+        response_json["UpdateRate"],
+        response_json["DataCount"],
+    )
+
+
+def stop_fieldbus_data_transfer(con_handle: ConnectionHandler) -> str:
+    """Closes the socket dedicated for the field bus data and stops
+    transfering data. The ring buffer allocated for the transfer data is
+    deleted.
+
+    Field bus data transfer must have been initiated before calling this
+    function.
+
+    Args:
+        con_handle: The unique connection identifier returned by GHSConnect
+
+    Returns:
+       String value representing request status.
+    """
+
+    response_json = con_handle.send_request_wait_response(
+        "StopFieldBusDataTransfer", None
+    )
+
+    return to_string(response_json[RETURN_KEY], GHSReturnValue)
+
+
+def get_fieldbus_data_count(
+    con_handle: ConnectionHandler,
+) -> tuple[str, int | None]:
+    """Gets the number of data that are configured to be sent through the
+    field bus, excluding the timestamp.
+
+    This method can be called by multiple connected clients at same
+    time.
+
+    Args:
+        con_handle: The unique connection identifier returned by GHSConnect
+
+    Returns:
+       Tuple with status and number of data that are selected to be published.
+    """
+
+    response_json = con_handle.send_request_wait_response(
+        "GetFieldBusDataCount", None
+    )
+
+    if ("DataCount" not in response_json) or (
+        response_json[RETURN_KEY] != GHSReturnValue["OK"]
+    ):
+        return to_string(response_json[RETURN_KEY], GHSReturnValue), None
+
+    return (
+        to_string(response_json[RETURN_KEY], GHSReturnValue),
+        response_json["DataCount"],
+    )
+
+
+def get_fieldbus_data_name_and_unit(
+    con_handle: ConnectionHandler, data_index: int
+) -> tuple[str, str | None, str | None]:
+    """Gets the name of specific field bus data value, by giving the index of
+    the data value. The number of data values can be retrieved by
+    GHSGetFieldBusDataCount. In case of no formulas (or reserved values
+    acquisition state and latency) published, an error code is returned:
+    GHSReturnValue_FieldBusError_NoFormulasDeployed.
+
+    This method can be called by multiple connected clients at same
+    time.
+
+    Args:
+        con_handle: A unique identifier per mainframe connection.
+        data_index: Zero-based index of the data value.
+
+    Returns:
+       Tuple with status, name and unit of the data value.
+    """
+
+    if not data_index and data_index != 0:
+        return "NullPtrArgument", None, None
+
+    data_info_dict = {
+        "DataIndex": data_index,
+    }
+
+    response_json = con_handle.send_request_wait_response(
+        "GetFieldBusDataNameAndUnit", data_info_dict
+    )
+
+    if (
+        not any(
+            key in response_json
+            for key in [
+                "DataName",
+                "DataUnit",
+            ]
+        )
+    ) or (response_json[RETURN_KEY] != GHSReturnValue["OK"]):
+        return (
+            to_string(response_json[RETURN_KEY], GHSReturnValue),
+            None,
+            None,
+        )
+
+    return (
+        to_string(response_json[RETURN_KEY], GHSReturnValue),
+        response_json["DataName"],
+        response_json["DataUnit"],
+    )
+
+
+def request_fieldbus_snapshot(
+    con_handle: ConnectionHandler,
+) -> tuple[str, float | None, int | None, list[float] | None]:
+    """Request a single snapshot of the field bus data. In this case the
+    timestamp received is not grid aligned. If the system is not acquiring the
+    method returns an error code:GHSReturnValue_SystemNotRecording In case of
+    no formulas you get the error return code back:
+    GHSReturnValue_FieldBusError_NotConfigured if the field bus is already
+    enabled then this method is not allowed.An error return code is
+    returned:FieldBusError_UnavailableFunctionality.
+
+    This method can be called by multiple connected clients at same
+    time.
+
+    Args:
+        con_handle: A unique identifier per mainframe connection.
+
+    Returns:
+       Tuple with status, timestamp, data count and data.
+    """
+
+    response_json = con_handle.send_request_wait_response(
+        "RequestSnapshot", None
+    )
+
+    if (
+        not any(
+            key in response_json
+            for key in [
+                "TimeStamp",
+                "DataCount",
+                "Data",
+            ]
+        )
+    ) or (response_json[RETURN_KEY] != GHSReturnValue["OK"]):
+        return (
+            to_string(response_json[RETURN_KEY], GHSReturnValue),
+            None,
+            None,
+            None,
+        )
+
+    return (
+        to_string(response_json[RETURN_KEY], GHSReturnValue),
+        response_json["TimeStamp"],
+        response_json["DataCount"],
+        response_json["Data"],
+    )
diff --git a/src/ghsapi/ghsapi.py b/src/ghsapi/ghsapi.py
index be92f46..e3bd6f9 100644
--- a/src/ghsapi/ghsapi.py
+++ b/src/ghsapi/ghsapi.py
@@ -35,6 +35,7 @@
 from . import acquisition_api as _acquisition
 from . import channel_api as _channel
 from . import connection_api as _connection
+from . import fieldbus_api as _fieldbus
 from . import mainframe_api as _mainframe
 from . import manage_mainframe_settings as _manage_mainframe_settings
 from . import manage_recordings_api as _manage_recordings
@@ -1612,3 +1613,122 @@ def ghs_set_timer_counter_range(
             lower_value,
             upper_value,
         )
+
+    # FieldBus API
+
+    def ghs_initiate_fieldbus_data_transfer(
+        self,
+        update_rate: int,
+    ) -> tuple[str, int | None, int | None]:
+        """Opens a new connection for the field bus data, and waits for client
+        to connect. Once the client connects, if the acquisition state is
+        active, data is sent to the client. Otherwise nothing is sent.
+
+        *If no formulas are present then you get error code
+        back:GHSReturnValue_FieldBusError_NotConfigured if the field bus is
+        already initiated then an error code is
+        returned:GHSReturnValue_FieldBusError_FieldBusEnabled. To change the
+        update rate the field bus needs to be stoped and inititate again with
+        a new update rate.*
+
+        Args:
+            update_rate: (in Hz) The update rate should be a part of the list
+            containing the supported update rates
+
+        Returns:
+            * GHSReturnValue - API return values
+            * update_rate - If the update rate selected by the user is not
+            supported, the mainframe will adjust the update rate, based on a
+            minimum distance from the supported rates and returns back to the
+            client.
+            * data_count - The number of published data on the setup.Timestamp
+            is not included in this count.
+        """
+
+        return _fieldbus.initiate_fieldbus_data_transfer(
+            self._con_handle,
+            update_rate,
+        )
+
+    def ghs_stop_fieldbus_data_transfer(
+        self,
+    ) -> str:
+        """Closes the socket dedicated for the field bus data and stops
+        transfering data. The ring buffer allocated for the transfer data is
+        deleted.
+
+        *Field bus data transfer must have been initiated before calling this
+        function*
+
+        Returns:
+            * GHSReturnValue - API return values
+        """
+
+        return _fieldbus.stop_fieldbus_data_transfer(
+            self._con_handle,
+        )
+
+    def ghs_get_fieldbus_data_count(
+        self,
+    ) -> tuple[str, int | None]:
+        """Gets the number of data that are configured to be sent through the
+        field bus, excluding the timestamp.
+
+        Returns:
+            * GHSReturnValue - API return values
+            * data_count - The number of data that are selected to be
+            published, excluding timestamp.
+        """
+
+        return _fieldbus.get_fieldbus_data_count(
+            self._con_handle,
+        )
+
+    def ghs_get_fieldbus_data_name_and_unit(
+        self,
+        data_index: int,
+    ) -> tuple[str, str | None, str | None]:
+        """Gets the name of specific field bus data value, by giving the index
+        of the data value. The number of data values can be retrieved by
+        GHSGetFieldBusDataCount(). In case of no formulas (or reserved values
+        acquisition state and latency) published, an error code is returned:
+        GHSReturnValue_FieldBusError_NoFormulasDeployed.
+
+        Args:
+            data_index: Zero-based index of the data value.
+
+        Returns:
+            * GHSReturnValue - API return values
+            * data_name - Name of the data value.
+            * data_unit - Unit of the data value.
+        """
+
+        return _fieldbus.get_fieldbus_data_name_and_unit(
+            self._con_handle,
+            data_index,
+        )
+
+    def ghs_request_fieldbus_snapshot(
+        self,
+    ) -> tuple[str, float | None, int | None, tuple[float] | None]:
+        """Request a single snapshot of the field bus data. In this case the
+        timestamp received is not grid aligned. If the system is not acquiring
+        the method returns an error code:GHSReturnValue_SystemNotRecording In
+        case of no formulas you get the error return code
+        back:GHSReturnValue_FieldBusError_NotConfigured if the field bus is
+        already enabled then this method is not allowed.An error return code
+        is returned:FieldBusError_UnavailableFunctionality.
+
+        Returns:
+            * GHSReturnValue - API return values
+            * timestamp - of the FieldBus data relative to start of
+            acquisition (not grid aligned) GHSGetAcquisitionStartTime
+            * data_count - Actuall number of elements(formulas) in the data
+            parameter. If number of elements allocated by the customer are
+            less than the actual formulas number, then we return an error code.
+            * data - Array of floats that contains the data
+        """
+
+        return _fieldbus.request_fieldbus_snapshot(
+            self._con_handle,
+        )
diff --git a/unittest/test_fieldbus_api.py b/unittest/test_fieldbus_api.py
new file mode 100644
index 0000000..7b9d963
--- /dev/null
+++ b/unittest/test_fieldbus_api.py
@@ -0,0 +1,389 @@
+# Copyright (C) 2022 Hottinger Bruel and Kjaer Benelux B.V.
+# Schutweg 15a
+# 5145 NP Waalwijk
+# The Netherlands
+# http://www.hbm.com
+
+# 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.
+
+"""FieldBus API unit test."""
+
+import os
+import sys
+import unittest
+from unittest.mock import patch
+
+import HtmlTestRunner
+
+currentdir = os.path.dirname(os.path.realpath(__file__))
+parentdir = os.path.dirname(currentdir)
+
+sys.path.append(os.path.join(parentdir, "src"))
+
+from ghsapi import connection, fieldbus_api, ghsapi_states
+
+
+class TestFieldbusAPI(unittest.TestCase):
+    """FieldBus API unit test."""
+
+    con_handle = connection.ConnectionHandler()
+    GHSReturnValue = ghsapi_states.GHSReturnValue
+    RETURN_KEY = ghsapi_states.RETURN_KEY
+
+    def setUp(self):
+        # run at start of test file
+        pass
+
+    def test_initiate_fieldbus_data_transfer(self):
+        """Test initiate_fieldbus_data_transfer api with success response"""
+
+        with patch(
+            "test_connection_handler.connection.ConnectionHandler.connection_establish"
+        ) as mock_con_est:
+            mock_con_est.return_value = self.GHSReturnValue["OK"]
+
+            with patch(
+                "test_connection_handler.connection.ConnectionHandler.send_request_wait_response"
+            ) as mock_req_ros:
+                mock_req_ros.return_value = {
+                    self.RETURN_KEY: self.GHSReturnValue["OK"],
+                    "UpdateRate": 1,
+                    "DataCount": 2,
+                }
+                self.assertEqual(
+                    fieldbus_api.initiate_fieldbus_data_transfer(
+                        self.con_handle, 1
+                    ),
+                    (
+                        "OK",
+                        1,
+                        2,
+                    ),
+                    "initiate_fieldbus_data_transfer success response test failed.",
+                )
+
+    def test_initiate_fieldbus_data_transfer_neg(self):
+        """Test initiate_fieldbus_data_transfer api with failure response"""
+
+        with patch(
+            "test_connection_handler.connection.ConnectionHandler.connection_establish"
+        ) as mock_con_est:
+
+            mock_con_est.return_value = self.GHSReturnValue["OK"]
+            with patch(
+                "test_connection_handler.connection.ConnectionHandler.send_request_wait_response"
+            ) as mock_req_ros:
+                mock_req_ros.return_value = {
+                    self.RETURN_KEY: self.GHSReturnValue["NOK"],
+                    "UpdateRate": 1,
+                    "DataCount": 2,
+                }
+                self.assertEqual(
+                    fieldbus_api.initiate_fieldbus_data_transfer(
+                        self.con_handle, 1
+                    ),
+                    ("NOK", None, None),
+                    "initiate_fieldbus_data_transfer failure response test failed.",
+                )
+                mock_req_ros.return_value = {
+                    self.RETURN_KEY: self.GHSReturnValue["NOK"],
+                }
+                self.assertEqual(
+                    fieldbus_api.initiate_fieldbus_data_transfer(
+                        self.con_handle, 1
+                    ),
+                    ("NOK", None, None),
+                    "initiate_fieldbus_data_transfer failure response test failed.",
+                )
+
+                mock_req_ros.return_value = {
+                    self.RETURN_KEY: self.GHSReturnValue["OK"],
+                }
+                self.assertEqual(
+                    fieldbus_api.initiate_fieldbus_data_transfer(
+                        self.con_handle, 1
+                    ),
+                    ("OK", None, None),
+                    "initiate_fieldbus_data_transfer failure response test failed.",
+                )
+
+    def test_initiate_fieldbus_data_transfer_null_args(self):
+        """Test initiate_fieldbus_data_transfer api with null args"""
+
+        with patch(
+            "test_connection_handler.connection.ConnectionHandler.connection_establish"
+        ) as mock_con_est:
+            mock_con_est.return_value = self.GHSReturnValue["OK"]
+
+        self.assertEqual(
+            fieldbus_api.initiate_fieldbus_data_transfer(
+                self.con_handle, None
+            ),
+            ("NullPtrArgument", None, None),
+            "initiate_fieldbus_data_transfer null argument check failed.",
+        )
+
+    def test_stop_fieldbus_data_transfer(self):
+        """Test stop_fieldbus_data_transfer api with success response"""
+
+        with patch(
+            "test_connection_handler.connection.ConnectionHandler.connection_establish"
+        ) as mock_con_est:
+            mock_con_est.return_value = self.GHSReturnValue["OK"]
+
+            with patch(
+                "test_connection_handler.connection.ConnectionHandler.send_request_wait_response"
+            ) as mock_req_ros:
+                mock_req_ros.return_value = {
+                    self.RETURN_KEY: self.GHSReturnValue["OK"],
+                }
+                self.assertEqual(
+                    fieldbus_api.stop_fieldbus_data_transfer(self.con_handle),
+                    "OK",
+                    "stop_fieldbus_data_transfer success response test failed.",
+                )
+
+    def test_get_fieldbus_data_count(self):
+        """Test get_fieldbus_data_count api with success response"""
+
+        with patch(
+            "test_connection_handler.connection.ConnectionHandler.connection_establish"
+        ) as mock_con_est:
+            mock_con_est.return_value = self.GHSReturnValue["OK"]
+
+            with patch(
+                "test_connection_handler.connection.ConnectionHandler.send_request_wait_response"
+            ) as mock_req_ros:
+                mock_req_ros.return_value = {
+                    self.RETURN_KEY: self.GHSReturnValue["OK"],
+                    "DataCount": 2,
+                }
+                self.assertEqual(
+                    fieldbus_api.get_fieldbus_data_count(self.con_handle),
+                    (
+                        "OK",
+                        2,
+                    ),
+                    "get_fieldbus_data_count success response test failed.",
+                )
+
+    def test_get_fieldbus_data_count_neg(self):
+        """Test get_fieldbus_data_count api with failure response"""
+
+        with patch(
+            "test_connection_handler.connection.ConnectionHandler.connection_establish"
+        ) as mock_con_est:
+
+            mock_con_est.return_value = self.GHSReturnValue["OK"]
+            with patch(
+                "test_connection_handler.connection.ConnectionHandler.send_request_wait_response"
+            ) as mock_req_ros:
+                mock_req_ros.return_value = {
+                    self.RETURN_KEY: self.GHSReturnValue["NOK"],
+                    "DataCount": 2,
+                }
+                self.assertEqual(
+                    fieldbus_api.get_fieldbus_data_count(self.con_handle),
+                    ("NOK", None),
+                    "get_fieldbus_data_count failure response test failed.",
+                )
+                mock_req_ros.return_value = {
+                    self.RETURN_KEY: self.GHSReturnValue["NOK"],
+                }
+                self.assertEqual(
+                    fieldbus_api.get_fieldbus_data_count(self.con_handle),
+                    ("NOK", None),
+                    "get_fieldbus_data_count failure response test failed.",
+                )
+
+                mock_req_ros.return_value = {
+                    self.RETURN_KEY: self.GHSReturnValue["OK"],
+                }
+                self.assertEqual(
+                    fieldbus_api.get_fieldbus_data_count(self.con_handle),
+                    ("OK", None),
+                    "get_fieldbus_data_count failure response test failed.",
+                )
+
+    def test_get_fieldbus_data_name_and_unit(self):
+        """Test get_fieldbus_data_name_and_unit api with success response"""
+
+        with patch(
+            "test_connection_handler.connection.ConnectionHandler.connection_establish"
+        ) as mock_con_est:
+            mock_con_est.return_value = self.GHSReturnValue["OK"]
+
+            with patch(
+                "test_connection_handler.connection.ConnectionHandler.send_request_wait_response"
+            ) as mock_req_ros:
+                mock_req_ros.return_value = {
+                    self.RETURN_KEY: self.GHSReturnValue["OK"],
+                    "DataName": "Latency",
+                    "DataUnit": "s",
+                }
+                self.assertEqual(
+                    fieldbus_api.get_fieldbus_data_name_and_unit(
+                        self.con_handle, 1
+                    ),
+                    (
+                        "OK",
+                        "Latency",
+                        "s",
+                    ),
+                    "get_fieldbus_data_name_and_unit success response test failed.",
+                )
+
+    def test_get_fieldbus_data_name_and_unit_neg(self):
+        """Test get_fieldbus_data_name_and_unit api with failure response"""
+
+        with patch(
+            "test_connection_handler.connection.ConnectionHandler.connection_establish"
+        ) as mock_con_est:
+
+            mock_con_est.return_value = self.GHSReturnValue["OK"]
+            with patch(
+                "test_connection_handler.connection.ConnectionHandler.send_request_wait_response"
+            ) as mock_req_ros:
+                mock_req_ros.return_value = {
+                    self.RETURN_KEY: self.GHSReturnValue["NOK"],
+                    "DataName": "Latency",
+                    "DataUnit": "s",
+                }
+                self.assertEqual(
+                    fieldbus_api.get_fieldbus_data_name_and_unit(
+                        self.con_handle, 1
+                    ),
+                    ("NOK", None, None),
+                    "get_fieldbus_data_name_and_unit failure response test failed.",
+                )
+                mock_req_ros.return_value = {
+                    self.RETURN_KEY: self.GHSReturnValue["NOK"],
+                }
+                self.assertEqual(
+                    fieldbus_api.get_fieldbus_data_name_and_unit(
+                        self.con_handle, 1
+                    ),
+                    ("NOK", None, None),
+                    "get_fieldbus_data_name_and_unit failure response test failed.",
+                )
+
+                mock_req_ros.return_value = {
+                    self.RETURN_KEY: self.GHSReturnValue["OK"],
+                }
+                self.assertEqual(
+                    fieldbus_api.get_fieldbus_data_name_and_unit(
+                        self.con_handle, 1
+                    ),
+                    ("OK", None, None),
+                    "get_fieldbus_data_name_and_unit failure response test failed.",
+                )
+
+    def test_get_fieldbus_data_name_and_unit_null_args(self):
+        """Test get_fieldbus_data_name_and_unit api with null args"""
+
+        with patch(
+            "test_connection_handler.connection.ConnectionHandler.connection_establish"
+        ) as mock_con_est:
+            mock_con_est.return_value = self.GHSReturnValue["OK"]
+
+        self.assertEqual(
+            fieldbus_api.get_fieldbus_data_name_and_unit(
+                self.con_handle, None
+            ),
+            ("NullPtrArgument", None, None),
+            "get_fieldbus_data_name_and_unit null argument check failed.",
+        )
+
+    def test_request_fieldbus_snapshot_count(self):
+        """Test request_fieldbus_snapshot api with success response"""
+
+        with patch(
+            "test_connection_handler.connection.ConnectionHandler.connection_establish"
+        ) as mock_con_est:
+            mock_con_est.return_value = self.GHSReturnValue["OK"]
+
+            with patch(
+                "test_connection_handler.connection.ConnectionHandler.send_request_wait_response"
+            ) as mock_req_ros:
+                mock_req_ros.return_value = {
+                    self.RETURN_KEY: self.GHSReturnValue["OK"],
+                    "TimeStamp": 0.999465000000986,
+                    "DataCount": 2,
+                    "Data": [1.0, 0.0010000000474974513],
+                }
+                self.assertEqual(
+                    fieldbus_api.request_fieldbus_snapshot(self.con_handle),
+                    (
+                        "OK",
+                        0.999465000000986,
+                        2,
+                        [1.0, 0.0010000000474974513],
+                    ),
+                    "request_fieldbus_snapshot success response test failed.",
+                )
+
+    def test_request_fieldbus_snapshot_neg(self):
+        """Test request_fieldbus_snapshot api with failure response"""
+
+        with patch(
+            "test_connection_handler.connection.ConnectionHandler.connection_establish"
+        ) as mock_con_est:
+
+            mock_con_est.return_value = self.GHSReturnValue["OK"]
+            with patch(
+                "test_connection_handler.connection.ConnectionHandler.send_request_wait_response"
+            ) as mock_req_ros:
+                mock_req_ros.return_value = {
+                    self.RETURN_KEY: self.GHSReturnValue["NOK"],
+                    "TimeStamp": 0.999465000000986,
+                    "DataCount": 2,
+                    "Data": [1.0, 0.0010000000474974513],
+                }
+                self.assertEqual(
+                    fieldbus_api.request_fieldbus_snapshot(self.con_handle),
+                    ("NOK", None, None, None),
+                    "request_fieldbus_snapshot failure response test failed.",
+                )
+                mock_req_ros.return_value = {
+                    self.RETURN_KEY: self.GHSReturnValue["NOK"],
+                }
+                self.assertEqual(
+                    fieldbus_api.request_fieldbus_snapshot(self.con_handle),
+                    ("NOK", None, None, None),
+                    "request_fieldbus_snapshot failure response test failed.",
+                )
+
+                mock_req_ros.return_value = {
+                    self.RETURN_KEY: self.GHSReturnValue["OK"],
+                }
+                self.assertEqual(
+                    fieldbus_api.request_fieldbus_snapshot(self.con_handle),
+                    ("OK", None, None, None),
+                    "request_fieldbus_snapshot failure response test failed.",
+                )
+
+
+if __name__ == "__main__":
+    unittest.main(
+        testRunner=HtmlTestRunner.HTMLTestRunner(
+            open_in_browser=True,
+            report_name="FieldBus API Unittest Report",
+            report_title="FieldBus API Unittest Report",
+        )
+    )
diff --git a/unittest/test_suite.py b/unittest/test_suite.py
index ead927d..3324bee 100644
--- a/unittest/test_suite.py
+++ b/unittest/test_suite.py
@@ -33,6 +33,7 @@
 import test_channel_api
 import test_connection_api
 import test_connection_handler
+import test_fieldbus_api
 import test_json
 import test_mainframe_api
 import test_manage_mainframe_settings
@@ -56,6 +57,7 @@
     suite.addTests(loader.loadTestsFromModule(test_manage_mainframe_settings))
     suite.addTests(loader.loadTestsFromModule(test_recorder_api))
     suite.addTests(loader.loadTestsFromModule(test_channel_api))
+    suite.addTests(loader.loadTestsFromModule(test_fieldbus_api))
 
     # initialize a runner, pass it your suite and run it
     HTMLTestRunner(
@@ -77,6 +79,7 @@
     suite.addTests(loader.loadTestsFromModule(test_manage_mainframe_settings))
     suite.addTests(loader.loadTestsFromModule(test_recorder_api))
     suite.addTests(loader.loadTestsFromModule(test_channel_api))
+    suite.addTests(loader.loadTestsFromModule(test_fieldbus_api))
 
     result = not XMLTestRunner(output="reports").run(suite).wasSuccessful()
     sys.exit(result)

From e6cfaf3edef1e34d60403c5efa1311f0c40f4764 Mon Sep 17 00:00:00 2001
From: Vishal Goel <vishal.goel@saviantconsulting.com>
Date: Tue, 21 Jun 2022 09:22:34 +0530
Subject: [PATCH 2/4] Fieldbus ring buffer class

---
 examples/example_ringbuffer.py     | 69 +++++++++++++++++++++++++
 src/ghsapi/fieldbus_ring_buffer.py | 83 ++++++++++++++++++++++++++++++
 2 files changed, 152 insertions(+)
 create mode 100644 examples/example_ringbuffer.py
 create mode 100644 src/ghsapi/fieldbus_ring_buffer.py

diff --git a/examples/example_ringbuffer.py b/examples/example_ringbuffer.py
new file mode 100644
index 0000000..b0cf442
--- /dev/null
+++ b/examples/example_ringbuffer.py
@@ -0,0 +1,69 @@
+# Copyright (C) 2022 Hottinger Bruel and Kjaer Benelux B.V.
+# Schutweg 15a
+# 5145 NP Waalwijk
+# The Netherlands
+# http://www.hbm.com
+
+# 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.
+
+"""Ring buffer class example.
+
+This is to help you get started with Ring buffer class"""
+
+import os
+import sys
+
+currentdir = os.path.dirname(os.path.realpath(__file__))
+parentdir = os.path.dirname(currentdir)
+
+sys.path.append(parentdir)
+
+from src.ghsapi import fieldbus_ring_buffer
+
+
+def main():
+    """Code example to use ring buffer class"""
+
+    ring_buffer = fieldbus_ring_buffer.FieldBusRingBuffer(5, 2)
+    print(f"Ring buffer current size {ring_buffer.ring_buffer_size()}")
+    print(
+        f"Is ring buffer empty? {'no' if ring_buffer.ring_buffer_size() else 'yes'}"
+    )
+    ring_buffer.put_data(100, [1.1, 1.2])
+    ring_buffer.put_data(101, [2.1, 2.2])
+    ring_buffer.put_data(102, [3.1, 3.2])
+    ring_buffer.put_data(103, [4.1, 4.2])
+    ring_buffer.put_data(104, [5.1, 5.2])
+    ring_buffer.put_data(104, [6.1, 6.2])
+    print(f"Ring buffer current size {ring_buffer.ring_buffer_size()}")
+    print(
+        f"Is ring buffer empty? {'no' if ring_buffer.ring_buffer_size() else 'yes'}"
+    )
+    print(ring_buffer.get_data())
+    print(ring_buffer.get_data())
+    print(ring_buffer.get_data())
+    print(ring_buffer.get_data())
+    print(ring_buffer.get_data())
+    print(ring_buffer.get_data())
+    ring_buffer.ring_buffer_free()
+    ring_buffer.put_data(102, [3.1, 3.2])
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/ghsapi/fieldbus_ring_buffer.py b/src/ghsapi/fieldbus_ring_buffer.py
new file mode 100644
index 0000000..853f70c
--- /dev/null
+++ b/src/ghsapi/fieldbus_ring_buffer.py
@@ -0,0 +1,83 @@
+"""FieldBus Ring Buffer"""
+
+from collections import deque
+
+
+class FieldBusData:
+    """FieldBus incoming packets, includes a timestamp and async values"""
+
+    def __init__(self) -> None:
+        self.time_stamp = None
+        self.values = []
+
+
+class RingBuffer:
+    """FieldBus Ring Buffer"""
+
+    def __init__(self):
+        self.buffer = None
+        self.capacity = None
+        self.overrun = None
+        self.data_count = None
+
+
+class FieldBusRingBuffer:
+    """FieldBus Ring Buffer Class"""
+
+    def __init__(self, size, data_count):
+        """Initialization of the FieldBus Ring Buffer Class"""
+
+        self.ring_buffer = RingBuffer()
+        self.ring_buffer.capacity = size
+        self.ring_buffer.data_count = data_count
+
+        self.ring_buffer_reset()
+
+    def ring_buffer_reset(self):
+        """Function to initialize some of the FieldBusRingBuf parameters"""
+
+        self.ring_buffer.buffer = deque(maxlen=self.ring_buffer.capacity)
+        self.ring_buffer.overrun = 0
+
+    def ring_buffer_free(self):
+        """Destruction of the FieldBus Ring Buffer"""
+
+        self.ring_buffer = None
+
+    def ring_buffer_empty(self):
+        """Checks if the FieldBus Ring Buffer is empty"""
+
+        return not self.ring_buffer.buffer
+
+    def ring_buffer_size(self):
+        """Retrieves the FieldBus Ring Buffer size"""
+
+        return len(self.ring_buffer.buffer)
+
+    def put_data(self, time_stamp, values):
+        """Insert FieldBusData in the FieldBus Ring Buffer"""
+
+        if not self.ring_buffer:
+            print("FieldBus Ring Buffer is null \n")
+            return
+
+        if self.ring_buffer_size() >= self.ring_buffer.capacity:
+            self.ring_buffer.overrun = 1
+
+        data = FieldBusData()
+        data.time_stamp = time_stamp
+        data.values = values
+
+        self.ring_buffer.buffer.append(data)
+
+    def get_data(self):
+        """Read FieldBusData in the FieldBus Ring Buffer"""
+
+        if not self.ring_buffer:
+            print("FieldBus Ring Buffer is null \n")
+            return 0
+
+        if not self.ring_buffer_empty():
+            data = self.ring_buffer.buffer.popleft()
+
+            return data.time_stamp, data.values, self.ring_buffer.overrun

From 3e07f96a731bedf5b0cbd51883cbff76fc7a596f Mon Sep 17 00:00:00 2001
From: Vishal Goel <vishal.goel@saviantconsulting.com>
Date: Tue, 21 Jun 2022 20:07:30 +0530
Subject: [PATCH 3/4] GHS return values added

---
 src/ghsapi/ghsapi_states.py | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/ghsapi/ghsapi_states.py b/src/ghsapi/ghsapi_states.py
index 211a6e4..87f85b9 100644
--- a/src/ghsapi/ghsapi_states.py
+++ b/src/ghsapi/ghsapi_states.py
@@ -66,7 +66,14 @@
     "MethodNotFound": 35,
     "InvalidJSONFormat": 36,
     "UnkownErrorMessage": 37,
+    "FieldBusError_NotConfigured": 38,
     "FieldBusAlready_Enabled": 39,
+    "NullFieldBusRingBuffer": 40,
+    "InvalidFieldBusPacket": 41,
+    "NotConnected": 42,
+    "NoFormulasDeployed": 43,
+    "BufferSizeInvalid": 44,
+    "FieldBusNotSupported": 45,
     "CANBusNotFound": 46,
     "WriteAccessBlocked": 47,
     "InvalidOutputNumber": 49,

From 36e8d9e5ae2013a7fb3e6ca1d9ce74d308166593 Mon Sep 17 00:00:00 2001
From: Afonso Coxito <afonso.coxito@hbkworld.com>
Date: Fri, 16 Jun 2023 13:16:30 +0200
Subject: [PATCH 4/4] Added missing methods with examples and documentation

---
 docs/doctrees/acquisition.doctree             | Bin 37428 -> 38402 bytes
 docs/doctrees/channel.doctree                 | Bin 48194 -> 47686 bytes
 docs/doctrees/channelanalog.doctree           | Bin 184807 -> 181017 bytes
 docs/doctrees/channeltimer.doctree            | Bin 51225 -> 50369 bytes
 docs/doctrees/connections.doctree             | Bin 17197 -> 17546 bytes
 docs/doctrees/environment.pickle              | Bin 96638 -> 904996 bytes
 docs/doctrees/fieldbus.doctree                | Bin 0 -> 51030 bytes
 docs/doctrees/ghspyapi.doctree                | Bin 3021 -> 3055 bytes
 docs/doctrees/index.doctree                   | Bin 4301 -> 4275 bytes
 docs/doctrees/introduction.doctree            | Bin 15058 -> 13780 bytes
 docs/doctrees/mainframe.doctree               | Bin 38117 -> 38360 bytes
 docs/doctrees/managemainframe.doctree         | Bin 19855 -> 20214 bytes
 docs/doctrees/managerecording.doctree         | Bin 48474 -> 48439 bytes
 docs/doctrees/recorder.doctree                | Bin 58924 -> 58504 bytes
 docs/doctrees/releasenotes.doctree            | Bin 4324 -> 4322 bytes
 docs/doctrees/remarks.doctree                 | Bin 4568 -> 4574 bytes
 docs/html/.buildinfo                          |   2 +-
 docs/html/_modules/ghsapi/ghsapi.html         | 356 ++++++--
 docs/html/_modules/index.html                 |  17 +-
 docs/html/_sources/fieldbus.rst.txt           |  12 +
 docs/html/_sources/ghspyapi.rst.txt           |   1 +
 .../_sphinx_javascript_frameworks_compat.js   | 123 +++
 docs/html/_static/basic.css                   |  55 +-
 docs/html/_static/css/badge_only.css          |   2 +-
 docs/html/_static/css/theme.css               |   4 +-
 docs/html/_static/doctools.js                 | 384 +++-----
 docs/html/_static/documentation_options.js    |   6 +-
 docs/html/_static/jquery.js                   |   4 +-
 docs/html/_static/language_data.js            | 102 +--
 docs/html/_static/searchtools.js              | 827 +++++++++---------
 docs/html/_static/sphinx_highlight.js         | 144 +++
 docs/html/acquisition.html                    |  57 +-
 docs/html/channel.html                        |  51 +-
 docs/html/channelanalog.html                  | 105 +--
 docs/html/channeltimer.html                   |  53 +-
 docs/html/connections.html                    |  41 +-
 docs/html/fieldbus.html                       | 278 ++++++
 docs/html/genindex.html                       |  35 +-
 docs/html/ghspyapi.html                       |  97 +-
 docs/html/index.html                          |  24 +-
 docs/html/introduction.html                   |  21 +-
 docs/html/mainframe.html                      |  52 +-
 docs/html/managemainframe.html                |  41 +-
 docs/html/managerecording.html                |  59 +-
 docs/html/objects.inv                         | Bin 1060 -> 1148 bytes
 docs/html/recorder.html                       |  67 +-
 docs/html/releasenotes.html                   |  94 +-
 docs/html/remarks.html                        |  21 +-
 docs/html/search.html                         |  17 +-
 docs/html/searchindex.js                      |   2 +-
 examples/example_fieldbus.py                  |  83 +-
 examples/example_ringbuffer.py                |   4 +-
 source/fieldbus.rst                           |  12 +
 source/ghspyapi.rst                           |   1 +
 src/ghsapi/connection.py                      |   9 +-
 src/ghsapi/fieldbus_api.py                    | 238 ++++-
 src/ghsapi/fieldbus_ring_buffer.py            |  83 --
 src/ghsapi/fieldbus_ringbuffer.py             | 117 +++
 src/ghsapi/ghsapi.py                          | 147 ++--
 src/ghsapi/ghsapi_states.py                   |   5 +
 60 files changed, 2462 insertions(+), 1391 deletions(-)
 create mode 100644 docs/doctrees/fieldbus.doctree
 create mode 100644 docs/html/_sources/fieldbus.rst.txt
 create mode 100644 docs/html/_static/_sphinx_javascript_frameworks_compat.js
 create mode 100644 docs/html/_static/sphinx_highlight.js
 create mode 100644 docs/html/fieldbus.html
 create mode 100644 source/fieldbus.rst
 delete mode 100644 src/ghsapi/fieldbus_ring_buffer.py
 create mode 100644 src/ghsapi/fieldbus_ringbuffer.py

diff --git a/docs/doctrees/acquisition.doctree b/docs/doctrees/acquisition.doctree
index 49678c29040364f37631950b9220999c550febcf..48794f0c8f2fc33bd5482c2f28fde8b612e24185 100644
GIT binary patch
literal 38402
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
RBFapYKAtKf4hIbj{|7p>aCHCx

literal 37428
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

diff --git a/docs/doctrees/channel.doctree b/docs/doctrees/channel.doctree
index d841824e4d05bc5181f1bc566eb1a1416ae1b61d..e44e07ed932743cae5d6eb48eba98fcf0c3c8704 100644
GIT binary patch
literal 47686
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
P7G^$Kw85FZH#hVDWUFOv

literal 48194
zcmdU2dyw5$dG~s~Pw%c@i4$_OMsY~I-t4Y1NhZ|PP?MO1Y*<VZpkSMe_FnBu^1afH
zq-*cC$>0zOWJVpDMl_^J$g6}D2;os+2#;W1rA!C@NXwM)s>8I*v_L{bnNEh3e&0Dq
z(vhxo^zdHW$&9mCN9UaHdA@Vb_tTM%_I>cOFRvp1x$Eqfsu@c&a=mVtb;b7F!Ma&%
zHx<M2?(nwX?A_!|xI>nF#5UVjP4V1SP@|@5jk={6-a*eD!|IOKuxD8N0b8j#nrQ^h
z)jqXf9XRMss6%d_qd5(QyX6jCuF8g?G(4;VHP&3OEFtOe#(O=&1$48??Qh9I*YVU1
z?oc&gRPA;98Gm!`nuca5-duZLc86uhv9$TN19G7py;|Kyo(F0T*|wn&e)k!2ll~g4
zw_D-Gyj(kEDGOMq?G8BdBHr@Ub!tT&QO{L-)p7Tl%Xb}kt7#oNu+K7e5Zc~j)c3vd
za{Itlubr*#-FN+gYn7IHU{STF7Zsx}-ypZN>DIENn#KXj?SUGVea5muq%E_n+w-7-
zA&^mCwB(k`>uC$qlVm9k*-`4!o_(*E7TN~UwLL@Cx7p3A7AkWmNV0=UGN*1qeW@=6
zC8_6u8P11)7r?)5@NYXPK)pzvR>##T;Bk$w0N`~k^^efN>-_?E;0<QI-2lZBvu+Nr
zLk3<8J^e|322k_6X?4QLAW_y}&1|;Jwo&JFMcqwZ1!gmAj-~Ma#_pv_s#d@`m_xb)
z;AxgdoMU3n9cAURAverL?^bWl9brX|)>JGgQQQ&Ds5RPkWkEyP(dT8grnrMmd8w|n
z9Mzlc0RnQ13=r_u#fCZW-RAbITD=bA={9$ibr2K`8tvx1VkvcRc9lC!hL3F;jb*4i
z48t;H5sh>mGtw~VYG2%<?mDK9=_BA=E#O#=8+k6OV{i&3a0+*z$xJHy{=pY<u7cFr
z7zr#TaFwCg`CjZh3s(}l%X^^LcNcS)cX95r0o-Mk+ou_IWvSCw()=Of0}y01V-doa
zyAuX=by0Du%mJ#-a!Z-mE=@o=jPe=w=gO<DlbQ+)`1*Fwy|CjRR_o}+Q~T!}PeyD0
zB}mLfpd%CnSOYP-*1`V-+!@0=Ra=8V<+Lr{=iTdpkwjt>cEfb4T78#fJJyusOGA{j
zOVSKyyEOf3$!WJ5%6?J<iliH*Inz)eGLV?Q${ituaRR{z=}#JJpSuRh`ZlE(p*j0O
zxKE~=bHZH<qD;3S+GDToC=wxIn_Mfr=ek2n&BiXfCFA@w2u*CoI;@bW^$DQz2&Lk_
z`vk(ZRl_(Are%L-TFbj&`T?DQM@Z&^l-IZzXu()RL}zh@ossMiI5BQ^lW#^9`VEmn
z2T`F^n}bNcQ<3Ud)hE#Lj)huNzeeT;V0j~98RsT&X~k-2FlTYbma<$a@E7W+K}UQi
zBYY=817dsh>}p(L1FXL9WWjY*EyvT<;`SJwVen@l|Br~B&LBb~=@tg5wj5j8xIMdk
z+VCq%^}j__Tb)#&4X6e~xk{ayQ*)0L(37I{^xmFTt3)J^bdc10unCp*--4;T7rdGh
zfwA3!l?%9dbqUr&oTb<_y4fX_BXa9!3;Bo+T<EoKHf7E5+|{jRSeZcq#!^_9k-_f4
z+7n7-3xcgjiMeZ`#BM1yZ9%KSEI0&1k<LsoBM-s_Z8!&xtZydr=^Nosd^S{n*)jVu
zvxifjKhOE=Ab))P5Onr0;2%!~I@{P8I*AG=)KIVf0-{RiAhs}yl}1(hYOyL4MbLK<
zY1Q8Z%%%INevO#G3mrNFCuIcm)zCJik?xmo7t+wj;C7r0b4*{9P=~!R0TIROXK~a+
zZ^YYC6*h#_)4Wl?5SoSFs88T!#1)ZJ30G91qkOK&gwO4b*%hAzw`G%I7}n|RZ7Hy3
zFl=swyPHMRezN-eNRyZWKGYopFj^%{;1Lt><70miQ}@T1|Ad(N<nciXB&#SPUOq0S
z!R^C{2eNpX?V%XPS42HifqJH5>iM3Sb)kClhL0Z$X$ZrI&=8%W;y;CyPI{<d+~?KP
z{|ULzp(lPs+!&br#+b=RR*O~{>WY~B93hPyq9l*KHMnnyi8CQ2mDA>KuQ{(rmnxLj
ziVQ!x(}Ep9&%qe;yT#0lY>_!z=zoR&6rV8MO)OssNxGTCnsTHDNkh+F=l`tAMol#>
zZXU@<xI`w^%~h6S*g>~b><=skVacb}J@@RijjZSPLlxMOdFnfG;dd=+CSacKo;i{4
zBPk3>2*S$VbBA$b1Qvu8o)_I%_OpehI~v*Fd2~I{3*5klbD`a6kd2A{PN0hWr-va8
z1N)}g9$?`iT#}Q$1f6MXrs43()i8NB6D+2rD{zO^ggmC?sPGRK#JI<l{SA7ssm`t#
zEQa(pQHgGgeTJKDP!h=cohJKcRHoiy%!58dZOu(ytH^a}TDo4<Y?g14YO*2CEAXe$
zfL!VPveaxh91Zdq5*WY$OG9a`p@AiANp>U~HnoskYbrC7H1Z9(gG#fd%C^QYiuCs&
z19U%r%}P>@4ea+9F_L~O)~@L9hCdxk%T9ahH)HiJv%OJ$4!Oe%n$oCOV;g%qeo5}0
z-0v9Lc#AcSZ_kJK`PqUX56l+@z6mrc`bP`N{1GbigZPIIHjq8!WZtYVcW?@~*UrOW
zg}hy=kVAN<syRxtvw7%p7qPs9G>u-TklY74mIFIkObFqqwUnA^)gjC3=gGzz(5)pm
zs<1FKjYY11H^^Hs-wLjyD*A3A6@7=Q=$r5dRI}Oblb$|$M?7hOclo3N)XSDA;3`L5
zuxy+L7l;#qhKhcS@GJx*^e3ozUnW)cufZQbezGYiG}k4O-MMeHKT|AodS1365|AA^
zhFCNlt4!^t|0CCNfB_WP!v7Z8BzRE{ltpJYdzJ{5W;49YcM0{*M=#70C^TEH>R`Dz
zrEJUnif~@Qa>6e4$5GUZ{)HU9evVefh`_@Z@f;4W4(_K_?<H0B2jEZCbtd$OxiWX)
zTDCj(N2h-sD3k=Ssotnr#7bZRY&$jz0+{}Jj&6q=Uj^$8O8PBwqpiS<hZrE;x=V+#
z$Q~YsI+s%b>v~)^Kzw4Whq!C&U+SPW5gA7A)@*uovJ6I={yG$g&X0Lo2MVMOEBaMM
zbcm}He>PhSUUCIA&X@rGsIiAsjf(rS+^P!~ANs*i;C$^vkxA2vUM(x~2#CDDsL1KV
z&F!aiqv!TaB6dQ@UPQsW8LJse2D?C#Fb8LB$l@3%G-T6-K)&w=zXk^UwW2!SvHb6x
zb##L?qN{Z}9wXo<Mv)1cqVA`NUVNwEr)BO2VcY@OO^`IUeh*#}xP`kOFie^Qz75yd
z50F@nP#@z|y*(O^0thx9%OdEcdT%Ezi3_q5hb76fP6SIn80B|D{it7%3_TLIc&Miw
z^!R8%B@1cPzX)dFr_5+<o>0H2J|5Zm`I&ye5B1LlZBO-9h#G=Gh+hw6@4y9VtrXCZ
z+zet6nYX?Z$d|N2nNYu{em_w+fD&@L(f<LvA-w%_z*}BWFa%PP5Wq0~AFPZ0nb^nw
zq7wa7C{Z%<qdx_WV4a)`Hu<HPKyu=R637jkJTIgnOoA~{LcIl$UUFhAAt^nwMl@h@
z=EV|Vlafj4L13q2)=7rHsPO4igg>+a#M6I3Z63N`mvFq7i?x|7$P|$|pF_S{Od#1I
zDS_M$d5w^U&>@*9oI@7I@!lb%Ufv-~;&^W-#)(cNDS?FwU&JA^>jIRQ7<=_QAZr_h
z-<5*!-rpVFmxu7)L$uEijdTd_9x?ODLxU2?9W6g5rokoQP6~wAsh)HQ@2g_gh3d%*
zP5qOQhA?sn4bchVJtd@c(xU|9KChmBE#y9jp7;@w4&nV?NG1isD=5lvpJ@G%LzLvP
zmjvOREhLrK=9j?+Fak!EM({dEUpj&}CFWf;`Z6a8hTtX76W4Vlf6{lE{BtkmAUd+^
zNQCG(?&8~Y{Zp_yqd=Xm0K57E{4cT-(RDOhIyR>_vDr1CW87y0D#tb{1WWo1TVJ>5
zbrY)jlP1l&O@t{PHwLnyEV<CQgo?p7Mc<Exujp?R+n<{_P=eC{jU$$%(5C(t#(V^g
zJAV>W(JY595gh<3_vY(gH~mUUF%T}UQ;1D}AE$L)$G+&E^}NguVrW^Th!TCYOoc`r
zJBm(y>x<YqMavT9?FRZ7Rn5(zYPyLz-cm-3?<%InK5+R^i~2pB2e5IMosH)aMCLJk
zQ82_vZsVRpLb06uUDzmy72qWaY5C0TIhBVCBgHYpDE5>y_wj{75;MH%v&4*PcoW{`
zlV{z)2;(%;XEz!MEBdDh&#@g?bO8I={zpmGNVdPjJf{*PJRVc9SSV(*pAezaY=(DZ
zHp>P21;ZyFqzL0VPAS`RPZ7?=LNauhT29!dj}d+>N3RTUzyY2UaQJIdH9IQh#0X!~
zA2o|u2`nCM#zq<Ohzm4VXTx^G!#*NTCTRK)gTG!mDL~=HC{r1rkTk65mljbZ0Sehf
zJ_;_o6B=jC{eI|}Ayp%x!@aP8@<O}lSBE0!?I9SAv~fkhrmWawAof*7#ZDi0`Vy?3
z^<_+-hDaf&;Yr44hL#CZxGe`;Y~bQZC^T@>B|yFzQs}QpeEdz^h$4l$zkLV>W+A*#
zzaRB?D~O{%fWO{{za9*JJp{kHfeqT+kwqNt<*>ncFTx{>d9cBFhndF`L%a~BAg33}
zNk#wU(u7(78@wNM&rg-nm@LKy?+MzT3T!a0H#kF%#|vZFU}r538|=6lgdDPdek_o$
zI5rsSM*k#s6T=2C&H{iFjLe>;3-Ov2feXJS6fz~Ne+(Msg$th)6G+bTPy)Hpnd3ql
z!h{<Wg+pijag>~dOMnZX6H?EcgX=tHRT3_Ih8QP0kcD<k5BWS?_!ZJ^_mBOZH6V&e
zDS~W*MtL3b0x^MPhol5@JLJVe8bXI;qHqpb7%to^q+Z@3OTvYFh;ec`Bo)4-LvG-g
zret1ZAv4sa|I!M2n3}D@qlM8qKohGn8N61Az&sw2dQe(FA|{aRjg&xcZ+x$ihR_?C
zD4_<6KTUC`ka~G<EEyi}AjZk%ja2v|-k4n%!Rw^OK@_|$uH|E=mzKYhq-8Ea#by>C
zrb*OD_hFij1z<8v6LQx9)7%NO;tIetzd&^{n1-$w2~2YrTUlhnG?nWVhdjSe@)!%I
zC3T*c64nW#p8h*@q>BFA-2Oy!lBeXTREPZ-IP)9E{7Qf`eS@HnlHkk$w#|M1fgNS)
zg+|$_gK>Q|c22>WM0x*~91VM`1qW|p=fjR@jfRBpQIcAgSyOBqo}<439-xQgU<;Pn
zL`NEqpA?ghXpTx;tZCW~G}I2mYn~PrTOtR2q=|h&$uKF|CGDJ+_9^h*H1fiyDd`o{
z(v^yFg?z)5bn&$GMj&EsPeQ}a4Hf<%9y2?=C5XXsTgq7coMIM7AStx?NdS^AD<l+4
z++Ko>#@X(77CidJ1SDNsNMZ&`%n>uDff9I^j|JTTlHxSdmm@T2SM*uJb8I!l&C{4E
zWN^e)q-rD^d|ClXH^vk!7K+(yi3pWuGrSwKS(kvMIHhdMwF&29Aq!Y;8^3w-PYI@>
zA`?+`HoAezv8#GGrdP2P%v28wO@()3raB9srAQJXSnRl|RUpL1d(1Y;eML<o?9#{f
z_U7o7K?E3cb3z0=N!1m@_I?W8@#+^_luZ#o!bTZWM2I2fK9ZO4ctRv<<?bk?t^Y5w
zS_ZNs4J-QdMf5`;JGQ)oH-GBCgT@&vLO)19mr*qlyW&Va!}!b~N3g43X3)a9gE=Nz
zx{zavM+U>L{6$b9?8@I$1&&t&ySik^$F45LUj(}%zq){3{c-%gh_++GD{_@8yc}{K
z-tUkBW8vF6qi^Nxco}A_!?K806`=R5zB9qC_&YZt$rF3$W&v<(4vdo?l*HiH)j?bL
zFHY^dGds)^!?|9X;UM&w@@6-)UN9{Z^y^@tfa2&^s671ub`wLtPSMFYTPRTqvS31^
zyvV}MVgkvzTuLB!F82dM8p2#I6Xis5xeo}bpY&Yry~H@NwMKGIo(i8nt?*FSA<}L4
zp{{R<wV5o)G0I%7qnb~O2_!otC6L=8j|*uC9g>N{Ib>m|>p3Cy@(x)N>UxG4CznG~
z;fpwAc3lJ)l45TZT;NZ}b<D5HsCVMaEyssN(`#wnmp>Wz5@0AAtJ6=$?G!VgJTxeQ
zWECYm81Nb~4KB@cQclKoswe$q+;w8sh3d(B;!76N5JrxIhA@ScN_#3Xd5PB?GVb&0
z=@udPIrPLM(dj4SZWoeCIT=?_l>3A<a)^>V_L5G<Jt`!X*XApCGOly<rJsyDCgxo<
z`Z6a8A978cC%Oi?o}XiLnEW0~ZbIuoU-!avy8`IzaZooV#PN_E-LDYz^-8w3$V6Xv
zg|DpC7T{|VWPdKf$uG7=2Z&6nYc|=gOUdBuiF6U{+w^DAZz}q)#qPt+I}`>OKmE42
z!~p-r<cPqy-9K~o2P8{#ece2B*0VP6@(B}Z3><y|c+1YsjqATh87Md$YVjmMh36C!
zisgaN!bZW+1NmM|P~oM8BxYE~PG|&Po$_8vyvygUx&al&X{65^G)7eP8NzdHZxf9r
zeir&7QZ<rvKdqp`YD~dmp_t9~6QR;<hIeB&>k?ELr<85EKP8-tg=A16wVbd^AD5cQ
z(JM>;;{eZ@{y&3MT`^qhPUwy|i&zOP9(mX(BOZm=kSpgoa|U(xl7#&gbRj?<$$^*W
zvc-bGQm`HPfE7H311pA;aun^;C~6s8i!`k0pDm(af@`sv3Ex@y7&Ok9%>0P*2~sr@
zQQX}puG7$p`gcN2oM6Y{dW`g0(Z5?(N%)q_Zx>Zk`ru6j|2TU*!uZUv2?75;l7lTa
z`f)fF8vW@K;7W*rfBv$j5cuaW>4VW-0{mMu;)8#E_=|vl<X5-AKmIAl7#LIz{1bFo
z7W{jszrPdooeBO;`5Pwk@IK&vkcBOOv~3GmCq49w(Z6$owx?oiB+y~UDK~=Z2^-Mp
zo>?!5S_J)@4ir!v{R@?+PhmGP^zV}Fvu|uR<lLY;hu<z2N|}NPz6Kgav&`wIJKiKF
zketY&1abo~RUr*wPK}Ae0Wf%|0@nk{dA5Wc_YFeodDCnwcKEGHj1ybsB?D<x`1HAk
zM+9F*y6rw9_(8EYlLfh*GM5Vxd`L_n*&!)`+z$C^Aq}BJGEq2(EQ|<#LrA^6LzYAY
zpCHD`<&aePvJROVGec#<H=Rii(tjc(xQ@pDUx+oB?1Voja`H$+dQ|)$F@a<!qy%z1
zVehDD_7^%K6D8E!5JgFSSDeTl9M2RoQQj9ZN|(T$HUK-2T+53)Z5MJcR3W9rdqX<z
zbeWJ$3hq=;l)XY4IYdb@Il4r2@LVUPRNmwz!w=O{ET)J?aI7kq-|L(Yv+Lpm2}#Sr
z=mQDGPdnb!B`ud6Sj)hUXww`!?U<;M?n7^)T|)A~$B@wu=<Q61;VS^WJ%pNL&>P(>
z5aj19HbZ1WZxegTl*S=!K}szdXv^Oq7}xq|(A(gpYq_0{rp!+XtR^xtJ01BblOqDF
zy^6fL(q6XV>tB+gD0N$MO#F(RR)_D#%`2cy`b9bVi7x;*7x1ItnrX1F#zo)TcnoRK
zo#!9nF^p0j$3p8jis;`5%$|ToqM^x5rGFJWr+`_aeqOAnDgQMz#Eb7V<x^!W{)1u`
z$J3Od#ZLl6`dlHQ7$os5HX3L7lo#7+%CRwEKKC(b2Dc4EqjZQA@A6%C10s#nNMG*I
zAX3o>2+y(29=C*odOo1BhE$CJ8mARR`pTGs#X>QgT|$IPgGlji%w}DJNaK{UEw__!
zE*6qOq<Jj2o9(pygOqi})-3qeVga}>cE&Q;tFu`(xDJ*nByT$()3I10X0~?-&4zbl
zW_txr=>=s9_;ky(h9Dj1BipF^iyBqfrH^~}<mi<lUl_G>B458ERaXr6{+pQ5#D2gg
znLDvj#v~IWrn!$%cH=ze-y^GKaBI@AqJO@Keh6;O7KnHr^E1#mV@>IY`NuM<CPK0t
zsgE;0GsqE0_K^%)IQuZiL`xTPO!3HIkgUIqDg?>;TfM;XN<gyDf;jYDqQAjk1d=7c
zx&X;e;c>fKvtGq7&cbFW1A;v-`TQl<L0QQ4O+Mtx^_2%=WqfnsT6v6hcwKaEh=v(4
z#@ZjWb#FTPCoDOobzrLNVkY+U<sIe0oJQu}mjnV8$4o<I=x1X$G0gPR9GGdRUAqIC
z?huNZ0-9a~jq-w~yTt^O;Q>k@cW!%DNJE$qW}<}fK=JhDK_T_>N#c^}%eN8ZM8~es
zj_I=jpCsN!y6rw_db3!Y$=U9kD08_$(+`LVBs(M}klP{e719toBol>mNFS-njaob=
zq+Z@3OQIGZC&tO;kW~1R4!KE54Vs}g2mMO^G!Pa<<NuRlB_{jf_lc-HQkIUJ9v2fx
z_Crb_w;w(uq#^V}CQ7Ke(zt2QdeO3?ygQbRk1r4#<yPUDLhgksq?CAXNXJdj7m`WA
zO$&;$Q%EC+D7hohYlM`_o4jNMqI!yj710QeRppX?ol|0VUBpe3mV_sYn`&Lsa>;?E
z06U_cZ45U})JWHG(@hEctCS;(A!8jlX%EDX6~IY9fSO`BDcv9toV1rk>r9+<9NxqU
z5MEPa6CONToA8R*j9S5Tr+*mz2wr5I+ns2JeEih!^oZK-VtjWK0euu{tS|!lSP^~u
z2<XS5k!X-H)94?=&M5+#sGsg1y!>XUvTh!{{B{{Fe!Z9$5mgMecoI;>pA`~{C47I3
zjmBBV;l+k3K3_;;26g<7m@y5Z!n-l3Ln2QvG)zZ=HzGT-X3*y!6nJHFjlAbLd`Q8~
zt_xlfr;)xGpaZj_KSy|u?S{Ao2GsM@&Cimmr!T7bvJFuMi-lq~lb}&L5{!3aHtQ0q
z7^jqNxpBg|SV)E{=CRz2zY|4R@$Ha)mUc*QHgHBKhXw7HQqvZ+n*RY>n*NKvsx{oZ
zvbiZN2xfPZ%$$p<RV)Ov)YU>u;oX>}w&su`;LFWZ8%9{1PPUz{ENUlVmp)MVs~qE&
z;V~G9bK)^Sq(l6HgwMx5%$2!0KgxJ(%qU_zvw7ndY?Lu?oF+iw{m5z=ppZ0#w*VK>
z4*?3<Ito8J_+e<AvGnpI_uUy)6M;gG)SZma3~~f0^fGASgu)yXEnUbl#Uq0Oh5pK@
z5K!pvbpppL0Tlii#GydpPw*E33dt`4P&ng%9o;=+a&k`%zh?kXavYW$@Wq5(lk^J)
z>X6$HdtlR8^zQKd`ufj-2J^l3@rL2DfrQ&%VAb4@Nc}t3uIR_%Pqw|s)hSrkpQBdP
zcOeDXDt?KJ6F?nC$3$ew;BKFsWPsD;Bpg&%W)^3pZF{x_$I=%x3%&t?RcKB$P?7!z
zCh~;-AMnf9gu9mO&`+ZV-*gTFJki9OjU_bE1C7WMVXM#X(?>tF=jo$&C9xdPbGP`l
z(}b(&*fVb!p?~A}C)z$2tn)&)b^O8qJZg<tA6tW8N6m5G<Rp8Zh?rw5edc-Vl(dz-
zOkiu=3>P5R#IA8O1RVutU?nk!oQ%mWo)?%yZu8B6ihcU%J(SU>kKQ|lSBzP>3~9NW
zp=P2$6&-skuKICM{rQ9sG0SY-m7)5rpn8@v$*cQWWV=)MBYaQ3^3zsd`(mPtMPb^1
z1Cbi`HY=ii?5()=w}AFvPxuhCoTmNs;YB7uw`bbJ+39hJVBt{n16$bG9rB+}w>^@5
z!vu1)a2vdSZTms&O&x~VI1-M(*$w=R=MJzhBXAvYMX_#rxo%dAVl&JaW*a_^<Ec}~
zLXSIEYg?9LI8|0Y=Z^R#4b4!zId>4A?RQ}NX?yO5x>;*GTEm`!5B3<2V$>ls`4%!I
zg%i-aId^DLF%(ONmyAIBp}OqAM}FjH3oh1DGF9mN5L^zk%eK{kt5L_SRp;f}A-oIZ
z`hYKM*>g88n5JWxj>6rX?QutKrREszW_1Zuj2@JX!DOhlsx`COgr+uhS)nCLLm?$q
z{G3p=){t#m!P}#(K~OMaDJ|1-stx6^((q<iyThv72rm2F4a$-Rx+1Sj@hkPYeRXBN
zy$Jn{9g!{EszVJ+k(*F5<XCb|L7}|&yJMQsYCG@>^_p3STHqROXJPu4)3ye`&yC)!
zDwbthRaG|NBm|th!--z2Ii9=DY&+3j`baOHJ080e>q7rK7$NQ$?KkAXZ+&j`My#>B
z9%ZmWQ7WjY0Wx{+XhSv@+xSv=kO!_;D~9K8q8W;6U1@=T02z&Fx*zfw3m_(FM5|X@
zma?EN!6QiSnA~>EYFOm1*1)Mo>+NQ%8aN&(mJ|T0qF9F9K+~-wC7@lyM)QY7En8{V
z&FWGUU246u)G}?Q%C{t5Qgf<@HCv-Dx~|IJlLvw@E(iPpp-#CYAdC$|K*n<?(CH|v
zR$YK^QQ000@y+-Ph}epSb^Mp)gUQ!g@{!;YTyz7DD)1a*5gf6hH8sb3!}@LRSW9VD
zK`9E1Mffxp5E;Rec^P=e!Qo1(<FxEuJ9Zp7a%85p?5J=8#<Ui9)Rn_Kpr*aUbI-&U
zgb`>_g#$HUCI`$i2<6iky!;Z->zK7ri;=;Skj#ZX85p!Oy6z#xn$Z+zff6%oJ5;CH
z0AfRqJP)I(?x^1EpgRt}*{lY`G!Ud}x6o5=bJyF;kj7f7s@kI3fPdh}YZ|z2bw})`
z3<K_lHjHl@6t;<6)5~hZtjSEp;}8#lA8-IV?m*i_mC*W7y9Ff1AUHXi19qVC;5P6g
zv!)pf;0u0$*oYy+ZqG;SjVR4|rC!yV;L0{KORsHb8EC7D;y~G%wT3Alswz!cYgFZW
z-Gc9z5q>vdmuPcaX)MsVcAML)7>7MrP`QINp1=SGU(}2`JdO>X=g8Kg0`UnvX9I8p
zzU4qzg+A)ag6-V|5ie4TACn=)(Az?A(T`)OPRa+ckp7;~Z-G&+AH`|(Ms->LbG%xD
z|FzvAtmQ1XNME$xoO<INsWR7A&$|iM<D}h)x~%RdjbMtqPkluH6n-WBbND~}@F4k+
zq>eAaBrnO-@k|~$ZmA>cL;%FLJIXr)VRE#lflHy3z&I_zvG3QT+TcrQJ<t(2PjlXE
z1pY;;o)IeyY7a$v9P+7>MjIpjLm0OloHx#l_r>n4a)%)@)yy`=9XR@2GaC(RZJ3<~
zE@$O;fW_YHT??bDC0j6F!B{r&Bw&4G5TGK(YlC9q8EZA8)@auuE|`nx6vK7Q^0IJ)
KQ+s=U=Klc)dXGc^

diff --git a/docs/doctrees/channelanalog.doctree b/docs/doctrees/channelanalog.doctree
index 23b4132ea2f353b47e01e9081cb720aabea809a5..831086f45549ce702342ca66ca1d6d77f450e9cd 100644
GIT binary patch
literal 181017
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
YrV8ls<LG>S1#GHCtA-<pshz|BA3Od)?*IS*

literal 184807
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
N%dm!1h}qqn|33;=7uNs)

diff --git a/docs/doctrees/channeltimer.doctree b/docs/doctrees/channeltimer.doctree
index 7c9f72eb76384a259361c1f1e167d32b970399bb..227eccc0b40c2090b6aec8b5a6c4bea8f603232d 100644
GIT binary patch
literal 50369
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

literal 51225
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
aqt$J~oVQodRSY-LKQdQ>%XW8Z?*9Q<O{O3K

diff --git a/docs/doctrees/connections.doctree b/docs/doctrees/connections.doctree
index fd2677f77bf861357fdfff5426c84ff6c15db11a..d1a1548e7fa63f9b0956b5c85416fb8260fd3b31 100644
GIT binary patch
delta 3644
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

delta 3367
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
LbO(#7Ul9HS`PRS`

diff --git a/docs/doctrees/environment.pickle b/docs/doctrees/environment.pickle
index f46df0902356158d9b37baf577f3ca473b4bbca6..c4a19908755ff6763f2b9da735a2b554619d594f 100644
GIT binary patch
literal 904996
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

literal 96638
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
S7YSQRyWp>Wryq7#rvE=B^tk%~

diff --git a/docs/doctrees/fieldbus.doctree b/docs/doctrees/fieldbus.doctree
new file mode 100644
index 0000000000000000000000000000000000000000..35137b0132a79762e0b556a1dbd5f33bb782a8ab
GIT binary patch
literal 51030
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
Jzk5sb{|kXoC7l2O

literal 0
HcmV?d00001

diff --git a/docs/doctrees/ghspyapi.doctree b/docs/doctrees/ghspyapi.doctree
index 5836579edd2cf84c8ccc11ec47b654e81fbc5653..0e2d5e13b3d5354fd7a0879f27d43399f1c06de8 100644
GIT binary patch
delta 211
zcmX>r{$8A=fpzMWi7fjj9_w?+aJGsGElw>ej&XF(ugEOPk15VCElN&}DM~HKFOCUF
z1+oiDGV}9dLQ67pGD|X3fr6DK8TolGMVV!(MUyKTr)(BvQex!x>)}YtOwCD2DlMLD
zz^uZQ5w|&nS&f--?&fN?9gGqZ86_nJ#a8<I1*rwadIex3^zw_+HwSarFpBYJ<|d}6
z#^>ZGrex-&Pw8RF$;`{1GI<{7KAG~2lHwlDyu{qplFEYA;wiOLGRixPGZcYz$>s{K
GP(}cSR8SlM

delta 179
zcmaDaepZ~NfpzMki7fkAGFUT&Cm!lk^>wz23C}OejtMBr&q_@$DR#_D3GjC=j`48v
zj&}_Ri3v(A$e%ocaSAhQhT&#qCS}ISA<T-K%bC@f8E0>v$F_q}K_R20q@dVJU%$M(
zT(6+ABqKjhFTW^VKP9zHzaX`scyk_y4I@8KYHm_$N_=K+VtQ)vl+MWqIQPkvW)v0o
eaONfErj}F|07Yx3WR&_9XD9;cqRq3oLKy);=s@-W

diff --git a/docs/doctrees/index.doctree b/docs/doctrees/index.doctree
index 3e33911b29ac0f6837e44d4c74f98a875e57dd9c..ea9c44cc53bcebc884fc81b9b257e91200a6b05c 100644
GIT binary patch
delta 288
zcmX@BxLJ{<fpzMNi7bC6voQ8Kq&i#0gche36~{O_=T~Hw<i`}}mlh?b#uTL%<QK;T
zqypImC7JnoF`*@yIhiGysX)QXl8pR3m!izF)S}7T85d2?Wh!Ep&aj;9z^27$K3R}i
zZnHh}FD9T+AW*0VNGE}$Sot%gGvX(IVmrm&oY9)mp3yn^FnbnnX@+cuPKKPf08qAQ
zvK5ChYXL~z<|2+?OpF&c=W_30l#s|MDJdwn($_CYEhyG20NbyZUzEPtmDh$*j5jkk
zF+DXtCqFSIGcSEg4@*vFUiOs96ZrOPugX}Su_$AHX%A;!Vs2_lWkG83l-em88LK)o
X7Il_pD1z9_Gk7xQ11+rL4`u`aBmioE

delta 314
zcmdn2cvg|6fpzMki7bCuGFUT&Co%S^dO2Iggy$D!#{?ARXQd{W6g%dn1o%4_$9On-
z$GZlE!~~@l<WD}wxJa0_hd(?uCpkYiRiPwbp(G<!Vanuureb#147LpE46Di7Y+8&K
zlLeUN_*r|n6*5wD3KY^Zb5ixDY}RG|%>+~y3RD&hR8|9Irvce1AT6x?Kvv@9n{21p
zTQk}-Iy1T_uVT;QEzgk6(8-YV768hYOjhJDW-S7#+Z@U9i;3~l<`C{3j0y@FB_##L
zR{Hwo<>h(>l_eSZd3yOp>G~<DW%>oF1;v|Hcx@Q@c~WzeQd8nHa}(23i>Gu>F5}y;
yy(VL2#*&PMr9GT^iMgpIl?6bV+9?_tYy2{n_?2cTg4ioFcrq3OZA{<~W&{9rYi!W~

diff --git a/docs/doctrees/introduction.doctree b/docs/doctrees/introduction.doctree
index 7ef82a3fb059a65e052d612363db4a276204d1d5..bf40b8af88053bd387af5b3582f83b11f617a380 100644
GIT binary patch
delta 2549
zcma)8ZA@EL81Cr@P)54~rL^9a(aBdwp&wf<Otv5+OE8FNGDBP^DRRecSK88BoNO^e
zW$^<t2XBqZ5;RMUF=AX||0r%mlP%G>$R@@g{%|7y3|aQe`C~D@=k!uo@1^pG9L{~-
z=Xsy!yyxEjJpRjR-K6gQAN;erZ)R^??2H~g6g)2SNiq1;(fF(3R6Hog$CEGf!6cuE
zi@|;#*NId(9t$2%g`?qAn8(eDln{?~C&RDs$;=t@4}mu|New5ogUPU;1Tu}<QG)-v
zp|;5fO~n~pKZlQeU@rNX2=H}DXE`TCggt^ru=fcyed9wy8ywcZfVeSAVGRiQ9Cs}<
z#F@U3em(tKx`}R4LftN0oq~|L);x@>P?kn;WqEjbrt~D4g@sZ-YCxWbZ5P$JoYMfg
z1~82>WPWdZjmENZvIz5KQDnP@Y)_D{wg;axTp)LV7>{8?D|rpg8herAH`-7mHNC<b
zQoCxmxX!QX*iCEJb0)Gij|8>COc;@HdHcRPO+BOx-Zgp6T*OFJs=U_jn>sXHq-w6J
zg~QGmLY7v<2<OY&wWV0Sz0UpeFAaXmUwjfz(K6$OZ=Dt}RdDb}g&ws7a_s|^LDW8i
z+AUO@BILm+6+WoM1CI1#;l6DOB|4Fg+=96e(L;#VF*J<T*l;6&ru-!)L>?$;?8mBK
z4R35Q=Ap*ssyVo8DM4RTa$lZmJi5p<3I?bkMJV`^7do>yKsUpI!@_~y>O`9P4VMZu
z5;=2u$vTASt2;#Z+bH_GjZCJbOr}^S<;XiJWm2Pb`*MvgutWZkGeL7jDJ(rUO;+J)
z?n#VgO&-e)jvn`4sL76-A{1g#D13VlEqu6PO`#AQrn@W%Pqi7&*o|PU*$twd)8bI8
zfmFHJsQgduy1f_X>>f5JYf>g_ERzb9xGQC%{6;F>yG}ac!QM`E-=&sav~#tmu$3Ox
z3ghpB)q1lsw#PxSCpO!re0f=6KXjK_HtZWl{OFGH%M5>>;fv^qcB$dE%ZePhm@Ge7
zQi*#<key!l!V~a0n}B<DHn`nX1l@ISk&ob3T{rr=BF|u;z8^I{-OS*Mlz{@))X<06
z#Z6BXBhP^DvJ9>@JdgNWJH|&FDgJkcchC%S{6((XKPNxg@<qZ&EEO}N=A~4WXW(Mf
zs`_6wj5&KT0F_2I1jhXXILXCu$DO?c6q4r&zko`WKe0+1t#r|D6)L4&nnvz|I`CMm
z@T^l0SDW1^-AoDCO(;wN9j+G<ewf19w5nj)Wy8Q!8Wu$riajh8MMh{@A{fG;JcO6r
z_(6?~P-^ymq!5J=<dr#B4RF1s0fsyWk!OPPG}A~Fc%<D&B7rYj9Z=(K#oFmy8ii}&
zGjBh_=W}TcN@)zTG~kj?OHP2d<#8Q*Tf%i;8yU>}?K`Vh-_vB0{zYQ73aL~=JmhvK
z_=MP+U_Y%|<H?asZ=i!%4B^qx2tOE&hlazkk@So<8jhV#!v}3k_1|MUk(>BOoYBWZ
bqkL*2!Hf7yDMBB-BMJ^&-prhBA0Yn$y=VwO

delta 3130
zcmai$ZA@EL7{_;7E^jN8LR((S%Wa_*N@;<?LSa)FA}$gv+t^^1EWC8w-2rWAk!*2f
z#!R!(jm)QnY=)R6ic#kz)|f?QpkFkGL^l`1Cv{)U5{+^5%bc2c&gp3x>%HDDr01UJ
z|9_t6ch7SVw~ybN;!bn(Uo~IkK1&feA@Aba1#3@xv-gmH^0?PC=@)&&p<vs@i0AqC
zp!eB5&mHOT9PsY*1^m$q=mE;(!rDW=v0?wXj}Q6zkl^DZa7G<W<AhYfBs4>h!H$}u
zwv=&%xTrH_0Hxr^E@(@yhp)LP4(rA1{Ui+5xO7-feG7@uo7Rdr@TS$};>|IkSWpWk
z-9l;i)R5qYrL=?0Jw#-sO(X{I7{jP4awhU}<W!_m;K+h(;7mJ_0B!la{wQ7#$IJvr
z%xx5|rVpTb$joTO33VAZl5pX%gr1Ce!Z%66Vv=wnDWUKxc}yDPH24?Dr#zTBg;rrb
za}2k!ibKDMch6<v)r!1uY5N)U12{C#sJU<hEN^cpBQ0)hEw?HTpvZ2AWsMQu*4P=Z
zpGl%7QvL=lU*+H*0Y+B;XZO0M2s*PWnb)5Q6fv(y*;5o76h$_6ye;2RS@vF(2gkDO
za7V>Zm0fJaC5Q&JZQItS;9B;sbb6%35(I5U4h!yr#!0>hx<m78ahMML+H&c)zoh*L
z?S}pwLbMK+wRHr6_*7E<1XK&$(OTfAoLW{*C#|M|R6|s<SS38clVN~&bh+@2ArlsL
zR_1t^I@;wO#ePy=BA*-dx!p`VMztK(LXN30mkXykc&F3JlVPAWP%1fi(L$({O3g%~
z+0QYNQs~ONhR(y^c^#NhEqjtn-_u+YC%9LrhqL-@;Bil<^*pO<VUrTk$WxMV{8u0E
z?!8Si$}TvE8x{>itb!FKt@v(?Dsy&2k1?+Oc9ZIy1XZG-RCSo@tTNU2@#Gp|pdbe>
zS7gG6`LpN`XensHbZu-$XTVPPli{8#@UnIuZUQB7@<1hA+6%q085XmkwWx-kG-VUY
z^Il;Wlky5uQKO=Vlo`8Wt|%_8CsKMw?@Q1m0!kBqiN)XLCwI~G8`=-&id!+aYRYZJ
zWT2<Amt@|0W&Butl+`^zlGAY|Ve;H0Os<r~O#+GLl}#wO{?ZYa{}lzP=#Oz@#%|D-
z#ijE^no4H7R|Ps#!DGWs6ck(@j_3h%g~D)OrO-;vg)qUNN1wny{L>hvi#;tONAP+w
z$pdB&>troKl7z{VlrTY-Zf5d*0*A5*C3(fNk4b+~kczirB$=@rI?ChH2SiFw;B{Cp
zFVJz}RQi>qA4w8VIqETij|oTVtD~>tj;c@%E!HlKt%+juTFVJGlRD`DzG3ZSlUuGP
z*B3p3Bu<{2gp0=(ciBl@=;$iDP;d`zhgk)Cl`0S$NdvJyh&FK_m;qVMaPtWlb9#X~
z(IaV6lOw6!df%9!r_!y;S3^K+k%SoivhoJP_{w0tvdluRsF@^oiR^a#|IAIh4Q8t|
z;X8Z$0)B0?8={rxnd}S$)g!Ev%hY8D87^g)Ell9aDl_bMIGNE0)QG+qX(RDc3@+Ps
z!-~Vhw5yvqXQXh>V4RJqMqJ}bij<?5H>}k(p~2{1H78XnT}pJS_EW_3LMRjnHoIKY
z)6>qtiICu*aQY`lT_e61T>)Pp811azg|r&q_>gbp$g%OkQC~1}7B20$Vf__XC*H+>
fg5ivb!Es;cL;&xdiil*RJ1Cg(&%4o=8v4+G?@gAg

diff --git a/docs/doctrees/mainframe.doctree b/docs/doctrees/mainframe.doctree
index 976af50ca65cb28b54ead1e20ec5f5335142f66d..8e9573d491793873f66db128de6941a2572a9042 100644
GIT binary patch
literal 38360
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
IXJzsK02rQ@9RL6T

literal 38117
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
Hpr!u@KHkLQ

diff --git a/docs/doctrees/managemainframe.doctree b/docs/doctrees/managemainframe.doctree
index a574f641f78a4c297f566d9fe9d32e7bc39aa471..7562a958873e8d0c9c5e9c387cd000acf3bf0fa5 100644
GIT binary patch
delta 4220
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
H_HzFN)xP@D

delta 3962
zcmbVPdu&tJ8SlOJ^()WCiE(1bk2nd5^CrRpC(t|qZ3~2iv<VX?EFoTQ4so2~P};R)
zp@Tg#uY-QxKtfaZ&pN8o(#q2I2Wtn?)FG{C)3&N=Mb{BD=(KhlTDtD7ec!p~I%aXV
zuz#-4>-&9=^E<zD{O4~;Uq2@)3(7Z6>^iNyZd4W3e)_E^YaZweM@Hj^4@CwK$655?
ze4=M|a&UKFBJ%Ox{sY?wABgOU&c)%p^nHV(wx!49S0%HenpBs%4{j7xK#y^_=8J2B
zIM+1*&l*aNDb+IooywSind30uQ#z#q_>&UB?~v(nF_!{=T`hdRT>+oP46^x*7{8#|
zn7c406WlRBE5?5cL!MT+X6X?9clbKLbt_*tW_?Z@XEI#2ZGvq!ujm(J-vcwAGWb_s
zHDCJ!Tg1ZCWQ`Ks3Dt=p>=4PD5k@_$jQsiggwg(NqX7IYe^eMfq<iLG77F%>@vq_d
zUSWJL+t?1DEj%O^UCelN6>XFT(tGd=zb$?_Phsy$_uZ$u*ex<`0AH_iZ<_+%kVU!)
zCrhqLAHuNxc@fFq39ixlR}K6F30`ve5!_h7mTAb-Z$O_n;ZW%@VNfBHfyF8FXv)(5
zGN&YkA?yfYjA3oGi`Gz#D==1s*#s{-0!1NhO*{S^nP45T<mk2y(U^IEN_D{dj#}t;
zS`ds6y4dh)FdKsH&I$I~x?V|zBIjnbS2agSh5rmD5A8og_7*)D*j4VWNtz~(%*;gR
zQ%Nb9I-)kPHbSV>D?uqV$?*8*pcLfBb((`RG!9toTBn$1tc6<VrUb{E8|^oEan(W9
zts2xyHAbf+9&Uu<3R~kdxH4&uPq6t%=b|b0UFupUqltrAee-O5dUi7UNP4<ruOznN
zM>1ToxnZ%@(|Vblap>gQkLg+WIy{Fjxd#Q_FEqSkTRbHzc<ko{jnVF@JR{b<udTCs
z$}GR5Nf)~fwVoO=`wyC}#AD_#-p1Ld@~gyz&43ddtc*r+*WZKNp3P#)ZNUA}PhS;W
zw1%9_X`p4}s`qoLI@OQ72<%U>zaY5RzTy_Q44w{{i`j3qKyGN*x1hvVCBG*_bFfvo
z=qB%OgFvu~z`G2v-cv1>4A2rDxzq)cUr#6^;_l)BVcb#wMqx3V9XAO;yOXhxjyuci
zK)Htkw`Kw-_Th-dv4Hi=QT{7cA>s6Fw$l-rrC=e@kZZ?=+9Oa=-63C=k%CT{U4mG3
zU*HvrPi;_#k=5GX_DksUWhx*t2zO=)V%?R{S91^#&^26*vp*r9_o_H*ty{iofcnsZ
zqQ4>i>yM{sD;0L#0B1rYBAZ_kaz=dKGU(#d&E6!}n)qC$rWRZg#;GIW1%-l9$4YaI
zmBYL1+l7x0xsM*9SIY#J$(^WJzsjC%ST$6KI(4Jo4d?4dgix1)RNquvV&oMn#GfM*
zsw1iRmKMO5I++sb(k;pgVX!{9PDvIHN9X6KXQvXriJACBbBd;nxH}CdwF%pK@K8fW
z9W5M@d+nF(&=hPFez#`(4gXiaVR$hZk`%ZStW*#`oaL*7d|8F~S&T4HUS;88=VA(<
z64JJ8ps8A+ZFjJESh1WH$CAMhOM@cHhbhVmQS$^9>F%0?v}yag)n#TK1oO|bF8P!Z
zIvpEr3Ohx{F7^}xHfk4&payC9lN772;a|m$w~BoMA=nB0WC?hd$(M{=z)xgnncxMm
zX0qhv5E6bB7Mh#NH3iR{lT0?G<4xY@$mMGoD7!$dYt(u^(|RH8ZRr;;Ds~I=sN|}>
zM2Tsty}0Jbl{w@>)gEixE9(3Kha=Hmfn&>rjG}#UOE}jsiixoP7>sYJgl=y;yuD$g
zT%f@5KrolZQ2QBqiP+;bu(ypcTiqMzP*#LQ^T&nc9g$SFkl-fnz}2{2+ql0|4ts6#
zUQ+f+Jx~|=bm3h(@*sROq`$aEIj*m?SbxS0E4q^OvOVNmQ<5HPew31|h1PSrBc0kY
zLc|9GuXsO~lmAKWMMY41QL9Q)RHd{)glfT3eVH<-(og6~>UsP*xt(Qn93I=;ARp6A
z#R-ln#Acn_c)AhRBDmcHr|&O^NO`HwZ+-hRDP{5dRg6~S_m8Q?`ORA|fVX87Je|ve
zRlml3ypU{lw_c|N?~UTqNN>{?o!);ysLqlV81{QY6x7Z!ymC+G;eUqAqhds6W*FZ_
zS8RSRw4wGWjNQLMx{mdzkl#=^!`n<N4A<OphQBFtB8I19-6tfxC%bVe?%7uIsoj%n
zrS~Bt+I7M&d(Yp^?%lB1_q4dch6uLNB3|gbFp>2=JISM`pJct0n*SH61wP~WI-{ou
zu2K|QFq&?@Pi?P<(e1@X7kiASsohzRU^G=WCb%|b;>sy>bW)oWT<bK^Q&=aOUd4>3
zETVk}BhZNU47E7Xc#DWup8n&GCuHgMbm9}2B%e>6pPx&FTUw4DJ=#3?=)4-AZH^zF
zYMG2a+%gxPOQd)7cS%M0(bz<E^1yU#d@7nqeFe_$eC3lDxfA>(lGfSrSd?Dd34Ee3
rnixo^etfO43)oik)t%~t>=Ma2z06Pm@k46M-k@`EJ^k%nBhtSCU=?NS

diff --git a/docs/doctrees/managerecording.doctree b/docs/doctrees/managerecording.doctree
index 38a662f476f62f99f36a77aeb9111623ef72643f..3081cc376b89022ffba552a014d29e97550b93bb 100644
GIT binary patch
literal 48439
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
Ef4bQVFaQ7m

literal 48474
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
Z-3IspYaZRlPy;_?!rco_<=xro{{tTCbB+K2

diff --git a/docs/doctrees/recorder.doctree b/docs/doctrees/recorder.doctree
index 4fef088d291aa5c342331a19e022f5be9a18bcc5..698b467a134d2f4559e8ddecf08a57246f1d49a7 100644
GIT binary patch
literal 58504
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

literal 58924
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

diff --git a/docs/doctrees/releasenotes.doctree b/docs/doctrees/releasenotes.doctree
index 7243cc382f100caf681bc22d5fb04fff3982ad31..87d77dea7b6c01602aee98449c6a78c7b929d7e0 100644
GIT binary patch
delta 196
zcmaE&_(+kZfpzNji7fjj9_w?+akh#HElw>ej&XF(ugEOPk15VCElN&}DM~HKFOCUF
z1+oiDGV}9dLQ67pGD|X3fr6DK8TolGMVV!(MUyKTE19J;3?|=Y(weNyw0ZI^riGj9
znb$H+HekC1l-LNAFq&-5p164d`$Sd=iHwqxf?_Lu{eskjV!Z;eL3;T`>6-(2Z5YLP
rGjkKuQ{!{;6H_wt(x>#W<YeY$PnkT2?+$xs#@x<~Po10V`BNDI^sr3L

delta 223
zcmaE)_(YMVfpzN5i7fkAGFUT&Cm!lk4Rp4O3C}OejtMBr&q_@$DR#_D3GjC=j`48v
zj&}_Ri3v(A$e%ocv67uN!ze>K!(ehRv({uYrp-XU6Oiu!=HFrFm@LPf!_1n&wz-pe
z9TQM;DNu4TSTcoeDUiPz$lnN8Y{#AmRy>b=603qjMoCFQv6a4ld3m{BL1jrsex6=_
zQM!IgYMFjPYC-X44_+HaexB6aq|}u7%-qEE)Z!_flV|bWVfV|J>zDD#Z*whwDkA`6
C%1s3T

diff --git a/docs/doctrees/remarks.doctree b/docs/doctrees/remarks.doctree
index 1589936be43184bcbf482f7989fbe9bdf2e4a6ed..1a36883b5e107189d8518ca342a3da984e3ac8cd 100644
GIT binary patch
delta 193
zcmcbid{3FBfpzNTi7cBY?&@<$ceaWNElw>ej&XF(ugEOPk15VCElN&}DM~HKFOCUF
z1+oiDGV}9dLQ67pGD|X3fr6DK8TolGMVV!(MVoUOGnkpBGpr^za2jpqV>M<3ast7e
zDz;b<Cj-n8;K*d$T+4ZoMM5H@q@<wON?*SqwV+t90Bn|Ceo^}7I6fOjG2YDF#Prno
foczR;%)Im|JuEqydD&AYujIeP*txkzAcheDY*j`U

delta 188
zcmcbod_$R~fpzNHi7cB~GFUT&CvNLg^>Ma}3C}OejtMBr&q_@$DR#_D3GjC=j`48v
zj&}_Ri3v(A$lu(;n8D1<nqjv2HA^NVJ8Oo2hIB^Y<o7H_n>*QJK>}$&fef&KGzVBk
zEl{8yEU=Tahebglqokyu*h*i&yu4hmpt2+*KTj{eC|y4#wM@StwV-%&ET0V{KTm3I
cQff+kW^Q77YVnlL$?N$qG5T$85{O|006*tJ!vFvP

diff --git a/docs/html/.buildinfo b/docs/html/.buildinfo
index 199a263..8bafe4f 100644
--- a/docs/html/.buildinfo
+++ b/docs/html/.buildinfo
@@ -1,4 +1,4 @@
 # Sphinx build info version 1
 # This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
-config: 0664fe191a9ad35cc50fd58c91c00a8b
+config: 90d7bbe8568ab2cd74f52ff18417acc1
 tags: 645f666f9bcd5a90fca523b33c5a78b7
diff --git a/docs/html/_modules/ghsapi/ghsapi.html b/docs/html/_modules/ghsapi/ghsapi.html
index 913f94a..d4a7891 100644
--- a/docs/html/_modules/ghsapi/ghsapi.html
+++ b/docs/html/_modules/ghsapi/ghsapi.html
@@ -10,10 +10,11 @@
     <script src="../../_static/js/html5shiv.min.js"></script>
   <![endif]-->
   
-        <script data-url_root="../../" id="documentation_options" src="../../_static/documentation_options.js"></script>
         <script src="../../_static/jquery.js"></script>
-        <script src="../../_static/underscore.js"></script>
+        <script src="../../_static/_sphinx_javascript_frameworks_compat.js"></script>
+        <script data-url_root="../../" id="documentation_options" src="../../_static/documentation_options.js"></script>
         <script src="../../_static/doctools.js"></script>
+        <script src="../../_static/sphinx_highlight.js"></script>
     <script src="../../_static/js/theme.js"></script>
     <link rel="index" title="Index" href="../../genindex.html" />
     <link rel="search" title="Search" href="../../search.html" /> 
@@ -24,11 +25,15 @@
     <nav data-toggle="wy-nav-shift" class="wy-nav-side">
       <div class="wy-side-scroll">
         <div class="wy-side-nav-search" >
-            <a href="../../index.html" class="icon icon-home"> GEN DAQ API - Python Driver
+
+          
+          
+          <a href="../../index.html" class="icon icon-home">
+            GEN DAQ API - Python Driver
           </a>
 <div role="search">
   <form id="rtd-search-form" class="wy-form" action="../../search.html" method="get">
-    <input type="text" name="q" placeholder="Search docs" />
+    <input type="text" name="q" placeholder="Search docs" aria-label="Search docs" />
     <input type="hidden" name="check_keywords" value="yes" />
     <input type="hidden" name="area" value="default" />
   </form>
@@ -54,9 +59,9 @@
         <div class="rst-content">
           <div role="navigation" aria-label="Page navigation">
   <ul class="wy-breadcrumbs">
-      <li><a href="../../index.html" class="icon icon-home"></a> &raquo;</li>
-          <li><a href="../index.html">Module code</a> &raquo;</li>
-      <li>ghsapi.ghsapi</li>
+      <li><a href="../../index.html" class="icon icon-home" aria-label="Home"></a></li>
+          <li class="breadcrumb-item"><a href="../index.html">Module code</a></li>
+      <li class="breadcrumb-item active">ghsapi.ghsapi</li>
       <li class="wy-breadcrumbs-aside">
       </li>
   </ul>
@@ -103,28 +108,20 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
 <span class="kn">from</span> <span class="nn">.</span> <span class="kn">import</span> <span class="n">acquisition_api</span> <span class="k">as</span> <span class="n">_acquisition</span>
 <span class="kn">from</span> <span class="nn">.</span> <span class="kn">import</span> <span class="n">channel_api</span> <span class="k">as</span> <span class="n">_channel</span>
 <span class="kn">from</span> <span class="nn">.</span> <span class="kn">import</span> <span class="n">connection_api</span> <span class="k">as</span> <span class="n">_connection</span>
+<span class="kn">from</span> <span class="nn">.</span> <span class="kn">import</span> <span class="n">fieldbus_api</span> <span class="k">as</span> <span class="n">_fieldbus</span>
 <span class="kn">from</span> <span class="nn">.</span> <span class="kn">import</span> <span class="n">mainframe_api</span> <span class="k">as</span> <span class="n">_mainframe</span>
 <span class="kn">from</span> <span class="nn">.</span> <span class="kn">import</span> <span class="n">manage_mainframe_settings</span> <span class="k">as</span> <span class="n">_manage_mainframe_settings</span>
 <span class="kn">from</span> <span class="nn">.</span> <span class="kn">import</span> <span class="n">manage_recordings_api</span> <span class="k">as</span> <span class="n">_manage_recordings</span>
 <span class="kn">from</span> <span class="nn">.</span> <span class="kn">import</span> <span class="n">recorder_api</span> <span class="k">as</span> <span class="n">_recorder</span>
 <span class="kn">from</span> <span class="nn">.connection</span> <span class="kn">import</span> <span class="n">ConnectionHandler</span>
-<span class="kn">from</span> <span class="nn">.ghsapi_states</span> <span class="kn">import</span> <span class="p">(</span>
-    <span class="n">RETURN_KEY</span><span class="p">,</span>
-    <span class="n">GHSChannelType</span><span class="p">,</span>
-    <span class="n">GHSDigitalOutMode</span><span class="p">,</span>
-    <span class="n">GHSDirection</span><span class="p">,</span>
-    <span class="n">GHSEnableDisable</span><span class="p">,</span>
-    <span class="n">GHSReturnValue</span><span class="p">,</span>
-    <span class="n">GHSSyncStatus</span><span class="p">,</span>
-    <span class="n">GHSTriggerMode</span><span class="p">,</span>
-    <span class="n">GHSUserMode</span><span class="p">,</span>
-<span class="p">)</span>
+<span class="kn">from</span> <span class="nn">.fieldbus_ringbuffer</span> <span class="kn">import</span> <span class="n">FieldBus</span>
+<span class="kn">from</span> <span class="nn">.ghsapi_states</span> <span class="kn">import</span> <span class="n">RETURN_KEY</span><span class="p">,</span> <span class="n">GHSReturnValue</span>
 
 <span class="n">CLIENT_API_VERSION</span> <span class="o">=</span> <span class="mi">4</span>
 
 
 <span class="k">class</span> <span class="nc">GHS</span><span class="p">:</span>
-    <span class="sd">&quot;&quot;&quot;GEN DAQ API object.</span>
+<span class="w">    </span><span class="sd">&quot;&quot;&quot;GEN DAQ API object.</span>
 
 <span class="sd">    Attributes:</span>
 <span class="sd">        _con_handle: An unique identifier per mainframe connection.</span>
@@ -132,10 +129,11 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
 
     <span class="k">def</span> <span class="fm">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
         <span class="bp">self</span><span class="o">.</span><span class="n">_con_handle</span> <span class="o">=</span> <span class="n">ConnectionHandler</span><span class="p">()</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">fieldbus_handle</span> <span class="o">=</span> <span class="n">FieldBus</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
 
     <span class="c1"># Connection related API functions.</span>
 <div class="viewcode-block" id="GHS.ghs_connect"><a class="viewcode-back" href="../../connections.html#ghsapi.ghsapi.GHS.ghs_connect">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_connect</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">ip_address</span><span class="p">:</span> <span class="nb">int</span><span class="p">,</span> <span class="n">port_num</span><span class="p">:</span> <span class="nb">int</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Establishes a connection to the mainframe.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Establishes a connection to the mainframe.</span>
 
 <span class="sd">        Args:</span>
 <span class="sd">            ip_address: IP address needs to be an IPV4 address.</span>
@@ -145,12 +143,22 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
 <span class="sd">            * GHSReturnValue - Connect return status.</span>
 <span class="sd">        &quot;&quot;&quot;</span>
 
-        <span class="k">return</span> <span class="n">_connection</span><span class="o">.</span><span class="n">connect</span><span class="p">(</span>
+        <span class="n">returnVal</span> <span class="o">=</span> <span class="n">_connection</span><span class="o">.</span><span class="n">connect</span><span class="p">(</span>
             <span class="bp">self</span><span class="o">.</span><span class="n">_con_handle</span><span class="p">,</span> <span class="n">ip_address</span><span class="p">,</span> <span class="n">port_num</span><span class="p">,</span> <span class="n">CLIENT_API_VERSION</span>
-        <span class="p">)</span></div>
+        <span class="p">)</span>
+        <span class="k">if</span> <span class="n">returnVal</span> <span class="o">!=</span> <span class="s2">&quot;OK&quot;</span><span class="p">:</span>
+            <span class="bp">self</span><span class="o">.</span><span class="n">_con_handle</span> <span class="o">=</span> <span class="kc">None</span>
+        
+        <span class="bp">self</span><span class="o">.</span><span class="n">fieldbus_handle</span><span class="o">.</span><span class="n">dataHandle</span> <span class="o">=</span> <span class="kc">None</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">fieldbus_handle</span><span class="o">.</span><span class="n">conHandle</span> <span class="o">=</span> <span class="n">ConnectionHandler</span><span class="p">()</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">fieldbus_handle</span><span class="o">.</span><span class="n">lastPacket</span><span class="o">.</span><span class="n">timeStamp</span> <span class="o">=</span> <span class="mi">0</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">fieldbus_handle</span><span class="o">.</span><span class="n">lastPacket</span><span class="o">.</span><span class="n">fValues</span> <span class="o">=</span> <span class="kc">None</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">fieldbus_handle</span><span class="o">.</span><span class="n">ipAddress</span> <span class="o">=</span> <span class="n">ip_address</span>
+        
+        <span class="k">return</span> <span class="n">returnVal</span></div>
 
 <div class="viewcode-block" id="GHS.ghs_disconnect"><a class="viewcode-back" href="../../connections.html#ghsapi.ghsapi.GHS.ghs_disconnect">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_disconnect</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Disconnects from a connected mainframe.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Disconnects from a connected mainframe.</span>
 
 <span class="sd">        *Results in error when the handle is not valid and / or</span>
 <span class="sd">        mainframe is not connected.*</span>
@@ -162,7 +170,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="k">return</span> <span class="n">_connection</span><span class="o">.</span><span class="n">disconnect</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_con_handle</span><span class="p">)</span></div>
 
 <div class="viewcode-block" id="GHS.ghs_get_client_api_version"><a class="viewcode-back" href="../../connections.html#ghsapi.ghsapi.GHS.ghs_get_client_api_version">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_get_client_api_version</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">int</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Client&#39;s API version.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Client&#39;s API version.</span>
 
 <span class="sd">        *This function can be useful when ghs_connect() returns</span>
 <span class="sd">        GHSReturnValue_APIMismatch.*</span>
@@ -174,7 +182,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="k">return</span> <span class="n">CLIENT_API_VERSION</span></div>
 
 <div class="viewcode-block" id="GHS.ghs_get_current_access"><a class="viewcode-back" href="../../connections.html#ghsapi.ghsapi.GHS.ghs_get_current_access">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_get_current_access</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Current access permission to the mainframe.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Current access permission to the mainframe.</span>
 
 <span class="sd">        *The current access permissions might change at any time.</span>
 <span class="sd">        For example, when Perception connects concurrently to the same</span>
@@ -193,7 +201,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
 
     <span class="c1"># Acquisition control related API functions.</span>
 <div class="viewcode-block" id="GHS.ghs_start_preview"><a class="viewcode-back" href="../../acquisition.html#ghsapi.ghsapi.GHS.ghs_start_preview">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_start_preview</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Starts preview mode.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Starts preview mode.</span>
 
 <span class="sd">        *The system needs to be idle before calling this function.*</span>
 
@@ -204,7 +212,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="k">return</span> <span class="n">_acquisition</span><span class="o">.</span><span class="n">start_preview</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_con_handle</span><span class="p">)</span></div>
 
 <div class="viewcode-block" id="GHS.ghs_stop_preview"><a class="viewcode-back" href="../../acquisition.html#ghsapi.ghsapi.GHS.ghs_stop_preview">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_stop_preview</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Stops preview mode.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Stops preview mode.</span>
 
 <span class="sd">        *The system needs to be in preview mode before calling this</span>
 <span class="sd">        function.*</span>
@@ -216,7 +224,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="k">return</span> <span class="n">_acquisition</span><span class="o">.</span><span class="n">stop_preview</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_con_handle</span><span class="p">)</span></div>
 
 <div class="viewcode-block" id="GHS.ghs_start_recording"><a class="viewcode-back" href="../../acquisition.html#ghsapi.ghsapi.GHS.ghs_start_recording">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_start_recording</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Start recording on local storage.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Start recording on local storage.</span>
 
 <span class="sd">        *The system needs to be idle before calling this function. Note</span>
 <span class="sd">        that the connected mainframe will generate a recording name.</span>
@@ -230,7 +238,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="k">return</span> <span class="n">_acquisition</span><span class="o">.</span><span class="n">start_recording</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_con_handle</span><span class="p">)</span></div>
 
 <div class="viewcode-block" id="GHS.ghs_pause_recording"><a class="viewcode-back" href="../../acquisition.html#ghsapi.ghsapi.GHS.ghs_pause_recording">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_pause_recording</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Pauses a started recording.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Pauses a started recording.</span>
 
 <span class="sd">        *The system needs to be recording before calling this function.*</span>
 
@@ -241,7 +249,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="k">return</span> <span class="n">_acquisition</span><span class="o">.</span><span class="n">pause_recording</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_con_handle</span><span class="p">)</span></div>
 
 <div class="viewcode-block" id="GHS.ghs_resume_recording"><a class="viewcode-back" href="../../acquisition.html#ghsapi.ghsapi.GHS.ghs_resume_recording">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_resume_recording</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Resumes a paused recording.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Resumes a paused recording.</span>
 
 <span class="sd">        *The system needs to be paused before calling this function.*</span>
 
@@ -252,7 +260,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="k">return</span> <span class="n">_acquisition</span><span class="o">.</span><span class="n">resume_recording</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_con_handle</span><span class="p">)</span></div>
 
 <div class="viewcode-block" id="GHS.ghs_stop_recording"><a class="viewcode-back" href="../../acquisition.html#ghsapi.ghsapi.GHS.ghs_stop_recording">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_stop_recording</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Stops a started recording.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Stops a started recording.</span>
 
 <span class="sd">        *The system needs to be recording before calling this function.*</span>
 
@@ -263,7 +271,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="k">return</span> <span class="n">_acquisition</span><span class="o">.</span><span class="n">stop_recording</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_con_handle</span><span class="p">)</span></div>
 
 <div class="viewcode-block" id="GHS.ghs_trigger"><a class="viewcode-back" href="../../acquisition.html#ghsapi.ghsapi.GHS.ghs_trigger">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_trigger</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Issues a trigger.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Issues a trigger.</span>
 
 <span class="sd">        Results in error when the trigger cannot be issued.</span>
 
@@ -274,7 +282,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="k">return</span> <span class="n">_acquisition</span><span class="o">.</span><span class="n">trigger</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_con_handle</span><span class="p">)</span></div>
 
 <div class="viewcode-block" id="GHS.ghs_get_acquisition_state"><a class="viewcode-back" href="../../acquisition.html#ghsapi.ghsapi.GHS.ghs_get_acquisition_state">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_get_acquisition_state</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">str</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
-        <span class="sd">&quot;&quot;&quot;Returns the Acquisition State of the Mainframe.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Returns the Acquisition State of the Mainframe.</span>
 
 <span class="sd">        Returns:</span>
 <span class="sd">            * GHSReturnValue - API return status</span>
@@ -286,7 +294,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
 <div class="viewcode-block" id="GHS.ghs_get_acquisition_start_time"><a class="viewcode-back" href="../../acquisition.html#ghsapi.ghsapi.GHS.ghs_get_acquisition_start_time">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_get_acquisition_start_time</span><span class="p">(</span>
         <span class="bp">self</span><span class="p">,</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">int</span> <span class="o">|</span> <span class="kc">None</span><span class="p">,</span> <span class="nb">int</span> <span class="o">|</span> <span class="kc">None</span><span class="p">,</span> <span class="nb">float</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
-        <span class="sd">&quot;&quot;&quot;Retrieves the absolute time of the start of acquisition.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Retrieves the absolute time of the start of acquisition.</span>
 
 <span class="sd">        Returns:</span>
 <span class="sd">            * GHSReturnValue - API return status</span>
@@ -298,7 +306,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="k">return</span> <span class="n">_acquisition</span><span class="o">.</span><span class="n">get_acquisition_start_time</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_con_handle</span><span class="p">)</span></div>
 
 <div class="viewcode-block" id="GHS.ghs_get_acquisition_time"><a class="viewcode-back" href="../../acquisition.html#ghsapi.ghsapi.GHS.ghs_get_acquisition_time">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_get_acquisition_time</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">float</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
-        <span class="sd">&quot;&quot;&quot;Retrieves the current acquisition time relative to the start</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Retrieves the current acquisition time relative to the start</span>
 <span class="sd">        of acquistion.</span>
 
 <span class="sd">        Returns:</span>
@@ -311,7 +319,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
     <span class="c1"># Mainframe APIs</span>
 
 <div class="viewcode-block" id="GHS.ghs_identify"><a class="viewcode-back" href="../../mainframe.html#ghsapi.ghsapi.GHS.ghs_identify">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_identify</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">identity_flag</span><span class="p">:</span> <span class="nb">bool</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Enable or disable the identification sound of the connected</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Enable or disable the identification sound of the connected</span>
 <span class="sd">        mainframe.</span>
 
 <span class="sd">        Args:</span>
@@ -324,7 +332,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="k">return</span> <span class="n">_mainframe</span><span class="o">.</span><span class="n">identity</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_con_handle</span><span class="p">,</span> <span class="n">identity_flag</span><span class="p">)</span></div>
 
 <div class="viewcode-block" id="GHS.ghs_get_disk_space"><a class="viewcode-back" href="../../mainframe.html#ghsapi.ghsapi.GHS.ghs_get_disk_space">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_get_disk_space</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">float</span> <span class="o">|</span> <span class="kc">None</span><span class="p">,</span> <span class="nb">float</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
-        <span class="sd">&quot;&quot;&quot;Get total and available mainframe internal disk space.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Get total and available mainframe internal disk space.</span>
 
 <span class="sd">        Returns:</span>
 <span class="sd">            * GHSReturnValue - API return status</span>
@@ -335,7 +343,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="k">return</span> <span class="n">_mainframe</span><span class="o">.</span><span class="n">get_disk_space</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_con_handle</span><span class="p">)</span></div>
 
 <div class="viewcode-block" id="GHS.ghs_get_sync_status"><a class="viewcode-back" href="../../mainframe.html#ghsapi.ghsapi.GHS.ghs_get_sync_status">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_get_sync_status</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">str</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
-        <span class="sd">&quot;&quot;&quot;Determine the mainframe sync status.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Determine the mainframe sync status.</span>
 
 <span class="sd">        Returns:</span>
 <span class="sd">            * GHSReturnValue - API return status</span>
@@ -345,7 +353,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="k">return</span> <span class="n">_mainframe</span><span class="o">.</span><span class="n">get_sync_status</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_con_handle</span><span class="p">)</span></div>
 
 <div class="viewcode-block" id="GHS.ghs_get_slot_count"><a class="viewcode-back" href="../../mainframe.html#ghsapi.ghsapi.GHS.ghs_get_slot_count">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_get_slot_count</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">int</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
-        <span class="sd">&quot;&quot;&quot;Retrieve the number of slots in the mainframe.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Retrieve the number of slots in the mainframe.</span>
 
 <span class="sd">        Returns:</span>
 <span class="sd">            * GHSReturnValue - API return status</span>
@@ -355,7 +363,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="k">return</span> <span class="n">_mainframe</span><span class="o">.</span><span class="n">get_slot_count</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_con_handle</span><span class="p">)</span></div>
 
 <div class="viewcode-block" id="GHS.ghs_get_user_mode"><a class="viewcode-back" href="../../mainframe.html#ghsapi.ghsapi.GHS.ghs_get_user_mode">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_get_user_mode</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">str</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
-        <span class="sd">&quot;&quot;&quot;Retrieve the user mode.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Retrieve the user mode.</span>
 
 <span class="sd">        Returns:</span>
 <span class="sd">            * GHSReturnValue - API return status</span>
@@ -365,7 +373,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="k">return</span> <span class="n">_mainframe</span><span class="o">.</span><span class="n">get_user_mode</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_con_handle</span><span class="p">)</span></div>
 
 <div class="viewcode-block" id="GHS.ghs_set_user_mode"><a class="viewcode-back" href="../../mainframe.html#ghsapi.ghsapi.GHS.ghs_set_user_mode">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_set_user_mode</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">user_mode</span><span class="p">:</span> <span class="nb">str</span> <span class="o">|</span> <span class="nb">int</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Set the user mode.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Set the user mode.</span>
 
 <span class="sd">        *The system needs to be idle before calling this function.*</span>
 
@@ -381,7 +389,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
 <div class="viewcode-block" id="GHS.ghs_get_mainframe_info"><a class="viewcode-back" href="../../mainframe.html#ghsapi.ghsapi.GHS.ghs_get_mainframe_info">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_get_mainframe_info</span><span class="p">(</span>
         <span class="bp">self</span><span class="p">,</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">str</span> <span class="o">|</span> <span class="kc">None</span><span class="p">,</span> <span class="nb">str</span> <span class="o">|</span> <span class="kc">None</span><span class="p">,</span> <span class="nb">str</span> <span class="o">|</span> <span class="kc">None</span><span class="p">,</span> <span class="nb">str</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
-        <span class="sd">&quot;&quot;&quot;Determine type, name, serial number and firmware version</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Determine type, name, serial number and firmware version</span>
 <span class="sd">        information for the connected mainframe.</span>
 
 <span class="sd">        *The mainframeType, mainframeName, serialNumber and</span>
@@ -400,7 +408,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
     <span class="c1"># Manage recordings APIs</span>
 
 <div class="viewcode-block" id="GHS.ghs_delete_all_recordings"><a class="viewcode-back" href="../../managerecording.html#ghsapi.ghsapi.GHS.ghs_delete_all_recordings">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_delete_all_recordings</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Deletes all recordings from local mainframe storage.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Deletes all recordings from local mainframe storage.</span>
 
 <span class="sd">        *Recordings are deleted asynchronously.*</span>
 
@@ -411,7 +419,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="k">return</span> <span class="n">_manage_recordings</span><span class="o">.</span><span class="n">delete_all_recordings</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_con_handle</span><span class="p">)</span></div>
 
 <div class="viewcode-block" id="GHS.ghs_delete_last_recording"><a class="viewcode-back" href="../../managerecording.html#ghsapi.ghsapi.GHS.ghs_delete_last_recording">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_delete_last_recording</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Deletes the most recent recording from local mainframe</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Deletes the most recent recording from local mainframe</span>
 <span class="sd">        storage.</span>
 
 <span class="sd">        *Recordings are deleted asynchronously.*</span>
@@ -423,7 +431,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="k">return</span> <span class="n">_manage_recordings</span><span class="o">.</span><span class="n">delete_last_recording</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_con_handle</span><span class="p">)</span></div>
 
 <div class="viewcode-block" id="GHS.ghs_get_recording_name"><a class="viewcode-back" href="../../managerecording.html#ghsapi.ghsapi.GHS.ghs_get_recording_name">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_get_recording_name</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">str</span> <span class="o">|</span> <span class="kc">None</span><span class="p">,</span> <span class="nb">int</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
-        <span class="sd">&quot;&quot;&quot;Retrieve the recording base name and recording index of the</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Retrieve the recording base name and recording index of the</span>
 <span class="sd">        last recording file.</span>
 
 <span class="sd">        *The recording base name parameter is UTF-8 encoded.*</span>
@@ -437,7 +445,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="k">return</span> <span class="n">_manage_recordings</span><span class="o">.</span><span class="n">get_recording_name</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_con_handle</span><span class="p">)</span></div>
 
 <div class="viewcode-block" id="GHS.ghs_get_storage_location"><a class="viewcode-back" href="../../managerecording.html#ghsapi.ghsapi.GHS.ghs_get_storage_location">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_get_storage_location</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">str</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
-        <span class="sd">&quot;&quot;&quot;Retrieve the storage location.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Retrieve the storage location.</span>
 
 <span class="sd">        Returns:</span>
 <span class="sd">            * GHSReturnValue - API return status</span>
@@ -449,7 +457,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
 <div class="viewcode-block" id="GHS.ghs_get_high_low_rate_storage_enabled"><a class="viewcode-back" href="../../managerecording.html#ghsapi.ghsapi.GHS.ghs_get_high_low_rate_storage_enabled">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_get_high_low_rate_storage_enabled</span><span class="p">(</span>
         <span class="bp">self</span><span class="p">,</span> <span class="n">source</span><span class="p">:</span> <span class="nb">str</span> <span class="o">|</span> <span class="nb">int</span><span class="p">,</span> <span class="n">slot_id</span><span class="p">:</span> <span class="nb">str</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">str</span> <span class="o">|</span> <span class="kc">None</span><span class="p">,</span> <span class="nb">str</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
-        <span class="sd">&quot;&quot;&quot;Retrieve storage enabled status of high and low rate data</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Retrieve storage enabled status of high and low rate data</span>
 <span class="sd">        for the specified recording data source.</span>
 
 <span class="sd">        Args:</span>
@@ -473,7 +481,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="n">high_rate_enabled</span><span class="p">:</span> <span class="nb">str</span> <span class="o">|</span> <span class="nb">int</span><span class="p">,</span>
         <span class="n">low_rate_enabled</span><span class="p">:</span> <span class="nb">str</span> <span class="o">|</span> <span class="nb">int</span><span class="p">,</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Enable/disable storage of high and low rate data for the</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Enable/disable storage of high and low rate data for the</span>
 <span class="sd">        specified recording data source.</span>
 
 <span class="sd">        Args:</span>
@@ -497,7 +505,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
 <div class="viewcode-block" id="GHS.ghs_set_recording_name"><a class="viewcode-back" href="../../managerecording.html#ghsapi.ghsapi.GHS.ghs_set_recording_name">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_set_recording_name</span><span class="p">(</span>
         <span class="bp">self</span><span class="p">,</span> <span class="n">recording_name</span><span class="p">:</span> <span class="nb">str</span><span class="p">,</span> <span class="n">recording_index</span><span class="p">:</span> <span class="nb">int</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Set the recording base name and recording index for the next</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Set the recording base name and recording index for the next</span>
 <span class="sd">        recording file.</span>
 
 <span class="sd">        *The system needs to be idle before calling this function.</span>
@@ -516,7 +524,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="p">)</span></div>
 
 <div class="viewcode-block" id="GHS.ghs_set_storage_location"><a class="viewcode-back" href="../../managerecording.html#ghsapi.ghsapi.GHS.ghs_set_storage_location">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_set_storage_location</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">storage_location</span><span class="p">:</span> <span class="nb">str</span> <span class="o">|</span> <span class="nb">int</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Set the storage location.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Set the storage location.</span>
 
 <span class="sd">        *The system needs to be idle before calling this function.*</span>
 
@@ -534,7 +542,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
     <span class="c1"># Manage recordings APIs</span>
 
 <div class="viewcode-block" id="GHS.ghs_apply_persisted_settings"><a class="viewcode-back" href="../../managemainframe.html#ghsapi.ghsapi.GHS.ghs_apply_persisted_settings">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_apply_persisted_settings</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;A mainframe might contain persisted settings (being applied upon</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;A mainframe might contain persisted settings (being applied upon</span>
 <span class="sd">        boot). This method re-applies these settings. In Perception this</span>
 <span class="sd">        maps on the &#39;Configured boot&#39; feature.</span>
 
@@ -551,7 +559,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="p">)</span></div>
 
 <div class="viewcode-block" id="GHS.ghs_persist_current_settings"><a class="viewcode-back" href="../../managemainframe.html#ghsapi.ghsapi.GHS.ghs_persist_current_settings">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_persist_current_settings</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Persists the current mainframe settings.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Persists the current mainframe settings.</span>
 
 <span class="sd">        *The persisted mainframe settings are applied upon a mainframe</span>
 <span class="sd">        boot.*</span>
@@ -565,7 +573,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="p">)</span></div>
 
 <div class="viewcode-block" id="GHS.ghs_get_current_settings"><a class="viewcode-back" href="../../managemainframe.html#ghsapi.ghsapi.GHS.ghs_get_current_settings">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_get_current_settings</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">bytes</span> <span class="o">|</span> <span class="kc">None</span><span class="p">,</span> <span class="nb">int</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
-        <span class="sd">&quot;&quot;&quot;Retrieves the current mainframe settings as a blob.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Retrieves the current mainframe settings as a blob.</span>
 
 <span class="sd">        *As this blob can be of variable size, it is upon the caller to</span>
 <span class="sd">        ensure reading the correct amount of memory.</span>
@@ -582,7 +590,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="p">)</span></div>
 
 <div class="viewcode-block" id="GHS.ghs_set_current_settings"><a class="viewcode-back" href="../../managemainframe.html#ghsapi.ghsapi.GHS.ghs_set_current_settings">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_set_current_settings</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">blob</span><span class="p">:</span> <span class="nb">bytes</span><span class="p">,</span> <span class="n">blob_size</span><span class="p">:</span> <span class="nb">int</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Persists the current mainframe settings.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Persists the current mainframe settings.</span>
 
 <span class="sd">        *The persisted mainframe settings are applied upon a mainframe</span>
 <span class="sd">        boot.*</span>
@@ -602,7 +610,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
     <span class="c1"># Recorder APIs</span>
 
 <div class="viewcode-block" id="GHS.ghs_get_channel_count"><a class="viewcode-back" href="../../recorder.html#ghsapi.ghsapi.GHS.ghs_get_channel_count">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_get_channel_count</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">slot_id</span><span class="p">:</span> <span class="nb">str</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">int</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
-        <span class="sd">&quot;&quot;&quot;Retrieve the number of channels for a recorder.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Retrieve the number of channels for a recorder.</span>
 
 <span class="sd">        *This method can be called by multiple connected clients at same</span>
 <span class="sd">        time.*</span>
@@ -620,7 +628,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
 <div class="viewcode-block" id="GHS.ghs_get_digital_output"><a class="viewcode-back" href="../../recorder.html#ghsapi.ghsapi.GHS.ghs_get_digital_output">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_get_digital_output</span><span class="p">(</span>
         <span class="bp">self</span><span class="p">,</span> <span class="n">slot_id</span><span class="p">:</span> <span class="nb">str</span><span class="p">,</span> <span class="n">digital_output</span><span class="p">:</span> <span class="nb">str</span> <span class="o">|</span> <span class="nb">int</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">str</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
-        <span class="sd">&quot;&quot;&quot;Retrieve the Digital Output Mode for a specified Output ID in a</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Retrieve the Digital Output Mode for a specified Output ID in a</span>
 <span class="sd">        recorder.</span>
 
 <span class="sd">        *This method can be called by multiple connected clients at same</span>
@@ -640,7 +648,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="p">)</span></div>
 
 <div class="viewcode-block" id="GHS.ghs_get_recorder_enabled"><a class="viewcode-back" href="../../recorder.html#ghsapi.ghsapi.GHS.ghs_get_recorder_enabled">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_get_recorder_enabled</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">slot_id</span><span class="p">:</span> <span class="nb">str</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">str</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
-        <span class="sd">&quot;&quot;&quot;Determine if recorder is enabled or disabled.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Determine if recorder is enabled or disabled.</span>
 
 <span class="sd">        *This method can be called by multiple connected clients at same</span>
 <span class="sd">        time.*</span>
@@ -658,7 +666,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
 <div class="viewcode-block" id="GHS.ghs_get_recorder_info"><a class="viewcode-back" href="../../recorder.html#ghsapi.ghsapi.GHS.ghs_get_recorder_info">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_get_recorder_info</span><span class="p">(</span>
         <span class="bp">self</span><span class="p">,</span> <span class="n">slot_id</span><span class="p">:</span> <span class="nb">str</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">str</span> <span class="o">|</span> <span class="kc">None</span><span class="p">,</span> <span class="nb">str</span> <span class="o">|</span> <span class="kc">None</span><span class="p">,</span> <span class="nb">str</span> <span class="o">|</span> <span class="kc">None</span><span class="p">,</span> <span class="nb">str</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
-        <span class="sd">&quot;&quot;&quot;Determine type, name, serial number and firmware version</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Determine type, name, serial number and firmware version</span>
 <span class="sd">        information for a recorder.</span>
 
 <span class="sd">        *The recorderType, recorderName, serialNumber and firmwareVersion</span>
@@ -681,7 +689,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="k">return</span> <span class="n">_recorder</span><span class="o">.</span><span class="n">get_recorder_info</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_con_handle</span><span class="p">,</span> <span class="n">slot_id</span><span class="p">)</span></div>
 
 <div class="viewcode-block" id="GHS.ghs_get_sample_rate"><a class="viewcode-back" href="../../recorder.html#ghsapi.ghsapi.GHS.ghs_get_sample_rate">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_get_sample_rate</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">slot_id</span><span class="p">:</span> <span class="nb">str</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">float</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
-        <span class="sd">&quot;&quot;&quot;Determine the sample rate for a recorder.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Determine the sample rate for a recorder.</span>
 
 <span class="sd">        *This method can be called by multiple connected clients at same</span>
 <span class="sd">        time.*</span>
@@ -702,7 +710,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="n">digital_output</span><span class="p">:</span> <span class="nb">str</span> <span class="o">|</span> <span class="nb">int</span><span class="p">,</span>
         <span class="n">digital_output_mode</span><span class="p">:</span> <span class="nb">str</span> <span class="o">|</span> <span class="nb">int</span><span class="p">,</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Set the Digital Output Mode for a specified Output ID in a</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Set the Digital Output Mode for a specified Output ID in a</span>
 <span class="sd">        recorder.</span>
 
 <span class="sd">        *This method will only process requests from the connected client</span>
@@ -727,7 +735,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="n">slot_id</span><span class="p">:</span> <span class="nb">str</span><span class="p">,</span>
         <span class="n">enabled</span><span class="p">:</span> <span class="nb">str</span> <span class="o">|</span> <span class="nb">int</span><span class="p">,</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Enable or disable a recorder.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Enable or disable a recorder.</span>
 
 <span class="sd">        *The system needs to be idle before calling this function.*</span>
 
@@ -752,7 +760,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="n">slot_id</span><span class="p">:</span> <span class="nb">str</span><span class="p">,</span>
         <span class="n">sample_rate</span><span class="p">:</span> <span class="nb">float</span><span class="p">,</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Set the sample rate for a recorder.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Set the sample rate for a recorder.</span>
 
 <span class="sd">        *The system needs to be idle before calling this function.</span>
 <span class="sd">        This function overwrites any previously set sample rate setting for</span>
@@ -782,7 +790,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
 <div class="viewcode-block" id="GHS.ghs_get_channel_type"><a class="viewcode-back" href="../../channel.html#ghsapi.ghsapi.GHS.ghs_get_channel_type">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_get_channel_type</span><span class="p">(</span>
         <span class="bp">self</span><span class="p">,</span> <span class="n">slot_id</span><span class="p">:</span> <span class="nb">str</span><span class="p">,</span> <span class="n">channel_index</span><span class="p">:</span> <span class="nb">int</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">int</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
-        <span class="sd">&quot;&quot;&quot;Determine the type of a channel.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Determine the type of a channel.</span>
 
 <span class="sd">        *Read - This method can be called by multiple connected clients at same</span>
 <span class="sd">        time.*</span>
@@ -803,7 +811,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
 <div class="viewcode-block" id="GHS.ghs_get_channel_name"><a class="viewcode-back" href="../../channel.html#ghsapi.ghsapi.GHS.ghs_get_channel_name">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_get_channel_name</span><span class="p">(</span>
         <span class="bp">self</span><span class="p">,</span> <span class="n">slot_id</span><span class="p">:</span> <span class="nb">str</span><span class="p">,</span> <span class="n">channel_index</span><span class="p">:</span> <span class="nb">int</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">int</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
-        <span class="sd">&quot;&quot;&quot;Determine the name of a channel.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Determine the name of a channel.</span>
 
 <span class="sd">        *The channel name is UTF-8 encoded*</span>
 
@@ -826,7 +834,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
 <div class="viewcode-block" id="GHS.ghs_set_channel_name"><a class="viewcode-back" href="../../channel.html#ghsapi.ghsapi.GHS.ghs_set_channel_name">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_set_channel_name</span><span class="p">(</span>
         <span class="bp">self</span><span class="p">,</span> <span class="n">slot_id</span><span class="p">:</span> <span class="nb">str</span><span class="p">,</span> <span class="n">channel_index</span><span class="p">:</span> <span class="nb">int</span><span class="p">,</span> <span class="n">channel_name</span><span class="p">:</span> <span class="nb">str</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Set the name for a channel.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Set the name for a channel.</span>
 
 <span class="sd">        *The channel name is UTF-8 encoded*</span>
 
@@ -850,7 +858,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
 <div class="viewcode-block" id="GHS.ghs_get_channel_storage_enabled"><a class="viewcode-back" href="../../channel.html#ghsapi.ghsapi.GHS.ghs_get_channel_storage_enabled">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_get_channel_storage_enabled</span><span class="p">(</span>
         <span class="bp">self</span><span class="p">,</span> <span class="n">slot_id</span><span class="p">:</span> <span class="nb">str</span><span class="p">,</span> <span class="n">channel_index</span><span class="p">:</span> <span class="nb">int</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">str</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
-        <span class="sd">&quot;&quot;&quot;Determine if storage is enabled or disabled for a channel.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Determine if storage is enabled or disabled for a channel.</span>
 
 <span class="sd">        *Read - This method can be called by multiple connected clients at same</span>
 <span class="sd">        time.*</span>
@@ -874,7 +882,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="n">channel_index</span><span class="p">:</span> <span class="nb">int</span><span class="p">,</span>
         <span class="n">enabled</span><span class="p">:</span> <span class="nb">str</span> <span class="o">|</span> <span class="nb">int</span><span class="p">,</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Enable or disable storage for a channel.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Enable or disable storage for a channel.</span>
 
 <span class="sd">        *The system needs to be idle before calling this function.*</span>
 
@@ -898,7 +906,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
 <div class="viewcode-block" id="GHS.ghs_cmd_zeroing"><a class="viewcode-back" href="../../channel.html#ghsapi.ghsapi.GHS.ghs_cmd_zeroing">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_cmd_zeroing</span><span class="p">(</span>
         <span class="bp">self</span><span class="p">,</span> <span class="n">slot_id</span><span class="p">:</span> <span class="nb">str</span><span class="p">,</span> <span class="n">channel_index</span><span class="p">:</span> <span class="nb">int</span><span class="p">,</span> <span class="n">ezeroing</span><span class="p">:</span> <span class="nb">str</span> <span class="o">|</span> <span class="nb">int</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Perform zeroing in a channel.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Perform zeroing in a channel.</span>
 
 <span class="sd">        *The system needs to be idle before calling this function.*</span>
 
@@ -925,7 +933,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span>
         <span class="nb">str</span><span class="p">,</span> <span class="nb">str</span> <span class="o">|</span> <span class="kc">None</span><span class="p">,</span> <span class="nb">float</span> <span class="o">|</span> <span class="kc">None</span><span class="p">,</span> <span class="nb">float</span> <span class="o">|</span> <span class="kc">None</span><span class="p">,</span> <span class="nb">float</span> <span class="o">|</span> <span class="kc">None</span><span class="p">,</span> <span class="nb">str</span> <span class="o">|</span> <span class="kc">None</span>
     <span class="p">]:</span>
-        <span class="sd">&quot;&quot;&quot;Determine the trigger settings for an analog channel.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Determine the trigger settings for an analog channel.</span>
 
 <span class="sd">        *Read - This method can be called by multiple connected clients at same</span>
 <span class="sd">        time.*</span>
@@ -957,7 +965,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="n">hysteresis</span><span class="p">:</span> <span class="nb">float</span><span class="p">,</span>
         <span class="n">direction</span><span class="p">:</span> <span class="nb">str</span> <span class="o">|</span> <span class="nb">int</span><span class="p">,</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Set the trigger settings for an analog channel.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Set the trigger settings for an analog channel.</span>
 
 <span class="sd">        *The system needs to be idle before calling this function.*</span>
 
@@ -999,7 +1007,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
 <div class="viewcode-block" id="GHS.ghs_get_signal_coupling"><a class="viewcode-back" href="../../channelanalog.html#ghsapi.ghsapi.GHS.ghs_get_signal_coupling">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_get_signal_coupling</span><span class="p">(</span>
         <span class="bp">self</span><span class="p">,</span> <span class="n">slot_id</span><span class="p">:</span> <span class="nb">str</span><span class="p">,</span> <span class="n">channel_index</span><span class="p">:</span> <span class="nb">int</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">str</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
-        <span class="sd">&quot;&quot;&quot;Determine the signal coupling for an analog channel.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Determine the signal coupling for an analog channel.</span>
 
 <span class="sd">        *Read - This method can be called by multiple connected clients at same</span>
 <span class="sd">        time.*</span>
@@ -1023,7 +1031,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="n">channel_index</span><span class="p">:</span> <span class="nb">int</span><span class="p">,</span>
         <span class="n">signal_coupling</span><span class="p">:</span> <span class="nb">str</span> <span class="o">|</span> <span class="nb">int</span><span class="p">,</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Set the signal coupling for an analog channel.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Set the signal coupling for an analog channel.</span>
 
 <span class="sd">        *If the specified signal coupling mode is not supported by the</span>
 <span class="sd">        recorder, the signal coupling mode remains unchanged.*</span>
@@ -1051,7 +1059,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
 <div class="viewcode-block" id="GHS.ghs_get_input_coupling"><a class="viewcode-back" href="../../channelanalog.html#ghsapi.ghsapi.GHS.ghs_get_input_coupling">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_get_input_coupling</span><span class="p">(</span>
         <span class="bp">self</span><span class="p">,</span> <span class="n">slot_id</span><span class="p">:</span> <span class="nb">str</span><span class="p">,</span> <span class="n">channel_index</span><span class="p">:</span> <span class="nb">int</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">str</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
-        <span class="sd">&quot;&quot;&quot;Determine the input coupling for an analog channel.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Determine the input coupling for an analog channel.</span>
 
 <span class="sd">        *Read - This method can be called by multiple connected clients at same</span>
 <span class="sd">        time.*</span>
@@ -1075,7 +1083,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="n">channel_index</span><span class="p">:</span> <span class="nb">int</span><span class="p">,</span>
         <span class="n">input_coupling</span><span class="p">:</span> <span class="nb">str</span> <span class="o">|</span> <span class="nb">int</span><span class="p">,</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Set the input coupling for an analog channel.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Set the input coupling for an analog channel.</span>
 
 <span class="sd">        *If the specified input coupling mode is not supported by the</span>
 <span class="sd">        recorder, the input coupling mode remains unchanged.*</span>
@@ -1103,7 +1111,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
 <div class="viewcode-block" id="GHS.ghs_get_span_and_offset"><a class="viewcode-back" href="../../channelanalog.html#ghsapi.ghsapi.GHS.ghs_get_span_and_offset">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_get_span_and_offset</span><span class="p">(</span>
         <span class="bp">self</span><span class="p">,</span> <span class="n">slot_id</span><span class="p">:</span> <span class="nb">str</span><span class="p">,</span> <span class="n">channel_index</span><span class="p">:</span> <span class="nb">int</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">float</span> <span class="o">|</span> <span class="kc">None</span><span class="p">,</span> <span class="nb">float</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
-        <span class="sd">&quot;&quot;&quot;Determine the span and offset for an analog channel.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Determine the span and offset for an analog channel.</span>
 
 <span class="sd">        *Read - This method can be called by multiple connected clients at same</span>
 <span class="sd">        time.*</span>
@@ -1129,7 +1137,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="n">span</span><span class="p">:</span> <span class="nb">float</span><span class="p">,</span>
         <span class="n">offset</span><span class="p">:</span> <span class="nb">float</span><span class="p">,</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Set Span and offset for analog channels.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Set Span and offset for analog channels.</span>
 
 <span class="sd">        *ReadWrite - This method will only process requests from the</span>
 <span class="sd">        connected client with the most privileges order (Privileges</span>
@@ -1156,7 +1164,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
 <div class="viewcode-block" id="GHS.ghs_get_filter_type_and_frequency"><a class="viewcode-back" href="../../channelanalog.html#ghsapi.ghsapi.GHS.ghs_get_filter_type_and_frequency">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_get_filter_type_and_frequency</span><span class="p">(</span>
         <span class="bp">self</span><span class="p">,</span> <span class="n">slot_id</span><span class="p">:</span> <span class="nb">str</span><span class="p">,</span> <span class="n">channel_index</span><span class="p">:</span> <span class="nb">int</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">str</span> <span class="o">|</span> <span class="kc">None</span><span class="p">,</span> <span class="nb">float</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
-        <span class="sd">&quot;&quot;&quot;Determine the filter type and frequency for an analog channel.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Determine the filter type and frequency for an analog channel.</span>
 
 <span class="sd">        *Read - This method can be called by multiple connected clients at same</span>
 <span class="sd">        time.*</span>
@@ -1182,7 +1190,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="n">filter_type</span><span class="p">:</span> <span class="nb">str</span> <span class="o">|</span> <span class="nb">int</span><span class="p">,</span>
         <span class="n">frequency</span><span class="p">:</span> <span class="nb">float</span><span class="p">,</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Set the filter type and frequency for an analog channel.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Set the filter type and frequency for an analog channel.</span>
 
 <span class="sd">        *This function overwrites any previously set filter settings</span>
 <span class="sd">        for the specified recorder.*</span>
@@ -1216,7 +1224,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
 <div class="viewcode-block" id="GHS.ghs_get_excitation"><a class="viewcode-back" href="../../channelanalog.html#ghsapi.ghsapi.GHS.ghs_get_excitation">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_get_excitation</span><span class="p">(</span>
         <span class="bp">self</span><span class="p">,</span> <span class="n">slot_id</span><span class="p">:</span> <span class="nb">str</span><span class="p">,</span> <span class="n">channel_index</span><span class="p">:</span> <span class="nb">int</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">str</span> <span class="o">|</span> <span class="kc">None</span><span class="p">,</span> <span class="nb">float</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
-        <span class="sd">&quot;&quot;&quot;Determine the excitation type and value for an analog channel.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Determine the excitation type and value for an analog channel.</span>
 
 <span class="sd">        *Read - This method can be called by multiple connected clients at same</span>
 <span class="sd">        time.*</span>
@@ -1242,7 +1250,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="n">excitation_type</span><span class="p">:</span> <span class="nb">str</span> <span class="o">|</span> <span class="nb">int</span><span class="p">,</span>
         <span class="n">excitation_value</span><span class="p">:</span> <span class="nb">float</span><span class="p">,</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Set the excitation type and value for an analog channel.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Set the excitation type and value for an analog channel.</span>
 
 <span class="sd">        *The system needs to be idle before calling this function.*</span>
 
@@ -1275,7 +1283,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
 <div class="viewcode-block" id="GHS.ghs_get_amplifier_mode"><a class="viewcode-back" href="../../channelanalog.html#ghsapi.ghsapi.GHS.ghs_get_amplifier_mode">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_get_amplifier_mode</span><span class="p">(</span>
         <span class="bp">self</span><span class="p">,</span> <span class="n">slot_id</span><span class="p">:</span> <span class="nb">str</span><span class="p">,</span> <span class="n">channel_index</span><span class="p">:</span> <span class="nb">int</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">str</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
-        <span class="sd">&quot;&quot;&quot;Determine the amplifier mode for an analog channel.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Determine the amplifier mode for an analog channel.</span>
 
 <span class="sd">        *Read - This method can be called by multiple connected clients at same</span>
 <span class="sd">        time.*</span>
@@ -1299,7 +1307,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="n">channel_index</span><span class="p">:</span> <span class="nb">int</span><span class="p">,</span>
         <span class="n">amplifier_mode</span><span class="p">:</span> <span class="nb">str</span> <span class="o">|</span> <span class="nb">int</span><span class="p">,</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Set the amplifier mode for an analog channel.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Set the amplifier mode for an analog channel.</span>
 
 <span class="sd">        *The system needs to be idle before calling this function.*</span>
 
@@ -1329,7 +1337,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
 <div class="viewcode-block" id="GHS.ghs_get_technical_units"><a class="viewcode-back" href="../../channelanalog.html#ghsapi.ghsapi.GHS.ghs_get_technical_units">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_get_technical_units</span><span class="p">(</span>
         <span class="bp">self</span><span class="p">,</span> <span class="n">slot_id</span><span class="p">:</span> <span class="nb">str</span><span class="p">,</span> <span class="n">channel_index</span><span class="p">:</span> <span class="nb">int</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">str</span> <span class="o">|</span> <span class="kc">None</span><span class="p">,</span> <span class="nb">float</span> <span class="o">|</span> <span class="kc">None</span><span class="p">,</span> <span class="nb">float</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
-        <span class="sd">&quot;&quot;&quot;Determine the technical units, unit multiplier and unit offset for</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Determine the technical units, unit multiplier and unit offset for</span>
 <span class="sd">        an analog channel.</span>
 
 <span class="sd">        *The units parameter is UTF-8 encoded.*</span>
@@ -1360,7 +1368,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="n">multiplier</span><span class="p">:</span> <span class="nb">float</span><span class="p">,</span>
         <span class="n">offset</span><span class="p">:</span> <span class="nb">float</span><span class="p">,</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Set the technical units, unit multiplier and unit offset for an</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Set the technical units, unit multiplier and unit offset for an</span>
 <span class="sd">        analog channel.</span>
 
 <span class="sd">        *The units parameter must be UTF-8 encoded.*</span>
@@ -1392,7 +1400,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
 <div class="viewcode-block" id="GHS.ghs_get_auto_range"><a class="viewcode-back" href="../../channelanalog.html#ghsapi.ghsapi.GHS.ghs_get_auto_range">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_get_auto_range</span><span class="p">(</span>
         <span class="bp">self</span><span class="p">,</span> <span class="n">slot_id</span><span class="p">:</span> <span class="nb">str</span><span class="p">,</span> <span class="n">channel_index</span><span class="p">:</span> <span class="nb">int</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">str</span> <span class="o">|</span> <span class="kc">None</span><span class="p">,</span> <span class="nb">float</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
-        <span class="sd">&quot;&quot;&quot;Determine the auto range enable and time settings.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Determine the auto range enable and time settings.</span>
 
 <span class="sd">        *Read - This method can be called by multiple connected clients at same</span>
 <span class="sd">        time.*</span>
@@ -1418,7 +1426,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="n">auto_range_enabled</span><span class="p">:</span> <span class="nb">str</span> <span class="o">|</span> <span class="nb">int</span><span class="p">,</span>
         <span class="n">auto_range_time</span><span class="p">:</span> <span class="nb">float</span><span class="p">,</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Set Auto range settings for analog channels.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Set Auto range settings for analog channels.</span>
 
 <span class="sd">        *ReadWrite - This method will only process requests from the</span>
 <span class="sd">        connected client with the most privileges order (Privileges</span>
@@ -1448,7 +1456,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="n">channel_index</span><span class="p">:</span> <span class="nb">int</span><span class="p">,</span>
         <span class="n">auto_range_time</span><span class="p">:</span> <span class="nb">float</span><span class="p">,</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Command a single shot for auto range.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Command a single shot for auto range.</span>
 
 <span class="sd">        *The system needs to be acquiring for this function to have any</span>
 <span class="sd">        effect.*</span>
@@ -1484,7 +1492,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="nb">str</span> <span class="o">|</span> <span class="kc">None</span><span class="p">,</span>
         <span class="nb">str</span> <span class="o">|</span> <span class="kc">None</span><span class="p">,</span>
     <span class="p">]:</span>
-        <span class="sd">&quot;&quot;&quot;Retrieve calibration information for an analog channel.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Retrieve calibration information for an analog channel.</span>
 
 <span class="sd">        *The calibrationDateTime, verificationDateTime,</span>
 <span class="sd">        powerVerificationDateTime, calibrationLab, verificationLab and</span>
@@ -1516,7 +1524,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
 <div class="viewcode-block" id="GHS.ghs_get_timer_counter_gate_time"><a class="viewcode-back" href="../../channeltimer.html#ghsapi.ghsapi.GHS.ghs_get_timer_counter_gate_time">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_get_timer_counter_gate_time</span><span class="p">(</span>
         <span class="bp">self</span><span class="p">,</span> <span class="n">slot_id</span><span class="p">:</span> <span class="nb">str</span><span class="p">,</span> <span class="n">channel_index</span><span class="p">:</span> <span class="nb">int</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">float</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
-        <span class="sd">&quot;&quot;&quot;Determine the gate time for a timer/counter channel.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Determine the gate time for a timer/counter channel.</span>
 
 <span class="sd">        *Read - This method can be called by multiple connected clients at same</span>
 <span class="sd">        time.*</span>
@@ -1540,7 +1548,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="n">channel_index</span><span class="p">:</span> <span class="nb">int</span><span class="p">,</span>
         <span class="n">gate_time</span><span class="p">:</span> <span class="nb">float</span><span class="p">,</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Determine the gate time for a timer/counter channel.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Determine the gate time for a timer/counter channel.</span>
 
 <span class="sd">        The system needs to be idle before calling this function.</span>
 
@@ -1571,7 +1579,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
 <div class="viewcode-block" id="GHS.ghs_get_timer_counter_mode"><a class="viewcode-back" href="../../channeltimer.html#ghsapi.ghsapi.GHS.ghs_get_timer_counter_mode">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_get_timer_counter_mode</span><span class="p">(</span>
         <span class="bp">self</span><span class="p">,</span> <span class="n">slot_id</span><span class="p">:</span> <span class="nb">str</span><span class="p">,</span> <span class="n">channel_index</span><span class="p">:</span> <span class="nb">int</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">str</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
-        <span class="sd">&quot;&quot;&quot;Determine the mode for a timer/counter channel.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Determine the mode for a timer/counter channel.</span>
 
 <span class="sd">        *Read - This method can be called by multiple connected clients at same</span>
 <span class="sd">        time.*</span>
@@ -1595,7 +1603,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="n">channel_index</span><span class="p">:</span> <span class="nb">int</span><span class="p">,</span>
         <span class="n">mode</span><span class="p">:</span> <span class="nb">str</span> <span class="o">|</span> <span class="nb">int</span><span class="p">,</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Set the mode for a timer/counter channel.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Set the mode for a timer/counter channel.</span>
 
 <span class="sd">        *The system needs to be idle before calling this function.*</span>
 
@@ -1625,7 +1633,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
 <div class="viewcode-block" id="GHS.ghs_get_timer_counter_range"><a class="viewcode-back" href="../../channeltimer.html#ghsapi.ghsapi.GHS.ghs_get_timer_counter_range">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_get_timer_counter_range</span><span class="p">(</span>
         <span class="bp">self</span><span class="p">,</span> <span class="n">slot_id</span><span class="p">:</span> <span class="nb">str</span><span class="p">,</span> <span class="n">channel_index</span><span class="p">:</span> <span class="nb">int</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">float</span> <span class="o">|</span> <span class="kc">None</span><span class="p">,</span> <span class="nb">float</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
-        <span class="sd">&quot;&quot;&quot;Determine the range for a timer/counter channel.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Determine the range for a timer/counter channel.</span>
 
 <span class="sd">        *Read - This method can be called by multiple connected clients at same</span>
 <span class="sd">        time.*</span>
@@ -1651,7 +1659,7 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
         <span class="n">lower_value</span><span class="p">:</span> <span class="nb">float</span><span class="p">,</span>
         <span class="n">upper_value</span><span class="p">:</span> <span class="nb">float</span><span class="p">,</span>
     <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
-        <span class="sd">&quot;&quot;&quot;Set the range for a timer/counter channel.</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Set the range for a timer/counter channel.</span>
 
 <span class="sd">        *The system needs to be idle before calling this function.*</span>
 
@@ -1680,6 +1688,166 @@ <h1>Source code for ghsapi.ghsapi</h1><div class="highlight"><pre>
             <span class="n">lower_value</span><span class="p">,</span>
             <span class="n">upper_value</span><span class="p">,</span>
         <span class="p">)</span></div>
+
+    <span class="c1"># FieldBus API</span>
+
+<div class="viewcode-block" id="GHS.ghs_initiate_fieldbus_data_transfer"><a class="viewcode-back" href="../../fieldbus.html#ghsapi.ghsapi.GHS.ghs_initiate_fieldbus_data_transfer">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_initiate_fieldbus_data_transfer</span><span class="p">(</span>
+        <span class="bp">self</span><span class="p">,</span>
+        <span class="n">update_rate</span><span class="p">:</span> <span class="nb">int</span><span class="p">,</span>
+    <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">int</span> <span class="o">|</span> <span class="kc">None</span><span class="p">,</span> <span class="nb">int</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;*Opens a new connection for the field bus data, and waits for client</span>
+<span class="sd">        to connect. Once the client connects, if the acquisition state is</span>
+<span class="sd">        active, data is sent to the client. Otherwise nothing is sent.*</span>
+
+<span class="sd">        *If no formulas are present then you get error code back:GHSReturnValue_FieldBusError_NotConfigured*</span>
+
+<span class="sd">        *If the field bus is already initiated then an error code is returned:</span>
+<span class="sd">        GHSReturnValue_FieldBusError_FieldBusEnabled.*</span>
+
+<span class="sd">        *To change the update rate the field bus needs to be stoped and inititated again with a new update rate.*</span>
+
+<span class="sd">        Args:</span>
+<span class="sd">            update_rate: (in Hz) The update rate should be a part of the list</span>
+<span class="sd">            containing the supported update rates</span>
+
+<span class="sd">        Returns:</span>
+<span class="sd">            * GHSReturnValue - API return values</span>
+<span class="sd">            * update_rate - If the update rate selected by the user is not supported, the mainframe will adjust the update rate based on a minimum distance from the supported rates and returns back to the client.</span>
+<span class="sd">            * data_count - The number of published data on the setup. Timestamp is not included in this count.</span>
+<span class="sd">        &quot;&quot;&quot;</span>
+
+        <span class="k">return</span> <span class="n">_fieldbus</span><span class="o">.</span><span class="n">initiate_fieldbus_data_transfer</span><span class="p">(</span>
+            <span class="bp">self</span><span class="o">.</span><span class="n">_con_handle</span><span class="p">,</span>
+            <span class="n">update_rate</span><span class="p">,</span>
+            <span class="bp">self</span><span class="o">.</span><span class="n">fieldbus_handle</span>
+        <span class="p">)</span></div>
+
+<div class="viewcode-block" id="GHS.ghs_stop_fieldbus_data_transfer"><a class="viewcode-back" href="../../fieldbus.html#ghsapi.ghsapi.GHS.ghs_stop_fieldbus_data_transfer">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_stop_fieldbus_data_transfer</span><span class="p">(</span>
+        <span class="bp">self</span><span class="p">,</span>
+    <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;*Closes the socket dedicated for the field bus data and stops transfering data.</span>
+<span class="sd">        The ring buffer allocated for the transfer data is deleted.*</span>
+
+<span class="sd">        *Field bus data transfer must have been initiated before calling this function*</span>
+
+<span class="sd">        Returns:</span>
+<span class="sd">            * GHSReturnValue - API return values</span>
+<span class="sd">        &quot;&quot;&quot;</span>
+
+        <span class="k">return</span> <span class="n">_fieldbus</span><span class="o">.</span><span class="n">stop_fieldbus_data_transfer</span><span class="p">(</span>
+            <span class="bp">self</span><span class="o">.</span><span class="n">_con_handle</span><span class="p">,</span>
+        <span class="p">)</span></div>
+
+<div class="viewcode-block" id="GHS.ghs_get_fieldbus_data_count"><a class="viewcode-back" href="../../fieldbus.html#ghsapi.ghsapi.GHS.ghs_get_fieldbus_data_count">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_get_fieldbus_data_count</span><span class="p">(</span>
+        <span class="bp">self</span><span class="p">,</span>
+    <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">int</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Gets the number of data that are configured to be sent through the field bus, excluding the timestamp.</span>
+
+<span class="sd">        Returns:</span>
+<span class="sd">            * GHSReturnValue - API return values</span>
+<span class="sd">            * data_count - The number of data that are selected to be published, excluding timestamp.</span>
+<span class="sd">        &quot;&quot;&quot;</span>
+
+        <span class="k">return</span> <span class="n">_fieldbus</span><span class="o">.</span><span class="n">get_fieldbus_data_count</span><span class="p">(</span>
+            <span class="bp">self</span><span class="o">.</span><span class="n">_con_handle</span><span class="p">,</span>
+        <span class="p">)</span></div>
+
+<div class="viewcode-block" id="GHS.ghs_get_fieldbus_data_name_and_unit"><a class="viewcode-back" href="../../fieldbus.html#ghsapi.ghsapi.GHS.ghs_get_fieldbus_data_name_and_unit">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_get_fieldbus_data_name_and_unit</span><span class="p">(</span>
+        <span class="bp">self</span><span class="p">,</span>
+        <span class="n">data_index</span><span class="p">:</span> <span class="nb">int</span><span class="p">,</span>
+    <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">str</span> <span class="o">|</span> <span class="kc">None</span><span class="p">,</span> <span class="nb">str</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;*Gets the name of specific field bus data value, by giving the index of the data value.</span>
+<span class="sd">        The number of data values can be retrieved by GHSGetFieldBusDataCount().*</span>
+
+<span class="sd">        *In case of no formulas (or reserved values acquisition state and latency) published,</span>
+<span class="sd">        an error code is returned: GHSReturnValue_FieldBusError_NoFormulasDeployed.*</span>
+
+<span class="sd">        Args:</span>
+<span class="sd">            data_index: Zero-based index of the data value.</span>
+
+<span class="sd">        Returns:</span>
+<span class="sd">            * GHSReturnValue - API return values</span>
+<span class="sd">            * data_name - Name of the data value.</span>
+<span class="sd">            * data_unit - Unit of the data value.</span>
+<span class="sd">        &quot;&quot;&quot;</span>
+
+        <span class="k">return</span> <span class="n">_fieldbus</span><span class="o">.</span><span class="n">get_fieldbus_data_name_and_unit</span><span class="p">(</span>
+            <span class="bp">self</span><span class="o">.</span><span class="n">_con_handle</span><span class="p">,</span>
+            <span class="n">data_index</span><span class="p">,</span>
+        <span class="p">)</span></div>
+
+<div class="viewcode-block" id="GHS.ghs_request_fieldbus_snapshot"><a class="viewcode-back" href="../../fieldbus.html#ghsapi.ghsapi.GHS.ghs_request_fieldbus_snapshot">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_request_fieldbus_snapshot</span><span class="p">(</span>
+        <span class="bp">self</span><span class="p">,</span>
+        <span class="n">dataCount</span><span class="p">:</span> <span class="nb">int</span>
+    <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">float</span> <span class="o">|</span> <span class="kc">None</span><span class="p">,</span> <span class="nb">int</span> <span class="o">|</span> <span class="kc">None</span><span class="p">,</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">float</span><span class="p">]</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;*Request a single snapshot of the field bus data.</span>
+<span class="sd">        In this case the timestamp received is not grid aligned.*</span>
+
+<span class="sd">        *If the system is not acquiring the method returns an error code:GHSReturnValue_SystemNotRecording*</span>
+
+<span class="sd">        *In case of no formulas you get the error return code back:GHSReturnValue_FieldBusError_NotConfigured*</span>
+
+<span class="sd">        *If the field bus is already enabled then this method is not allowed.</span>
+<span class="sd">        An error return code is returned:FieldBusError_UnavailableFunctionality.*</span>
+
+<span class="sd">        Returns:</span>
+<span class="sd">            * GHSReturnValue - API return values</span>
+<span class="sd">            * timestamp - Timestamp of the FieldBus data relative to start of acquisition (not grid aligned) GHSGetAcquisitionStartTime</span>
+<span class="sd">            * data_count - Actual number of elements(formulas) in the data parameter. If number of elements allocated by the customer are less than the actual formulas number, then we return an error code.</span>
+<span class="sd">            * data - Array of floats that contains the data</span>
+<span class="sd">        &quot;&quot;&quot;</span>
+
+        <span class="k">return</span> <span class="n">_fieldbus</span><span class="o">.</span><span class="n">request_fieldbus_snapshot</span><span class="p">(</span>
+            <span class="bp">self</span><span class="o">.</span><span class="n">_con_handle</span><span class="p">,</span>
+            <span class="n">dataCount</span>
+        <span class="p">)</span></div>
+
+<div class="viewcode-block" id="GHS.ghs_receive_fieldbus_data"><a class="viewcode-back" href="../../fieldbus.html#ghsapi.ghsapi.GHS.ghs_receive_fieldbus_data">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_receive_fieldbus_data</span><span class="p">(</span>
+        <span class="bp">self</span><span class="p">,</span>
+    <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">str</span><span class="p">:</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Used to retrieve the FieldBus data from the new socket connection and write on the buffer.</span>
+
+<span class="sd">        *Can be used in a thread and if so, mutual exclusion should be used with GHSStopFieldBusDataTransfer.*</span>
+
+<span class="sd">        *This function should be used in a loop if continuous delivery of Async Data is desired.*</span>
+
+<span class="sd">        *Field bus data transfer must have been initiated before calling this function.*</span>
+
+<span class="sd">        Returns:</span>
+<span class="sd">            * GHSReturnValue - API return values</span>
+<span class="sd">        &quot;&quot;&quot;</span>
+
+        <span class="k">return</span> <span class="n">_fieldbus</span><span class="o">.</span><span class="n">receive_fieldbus_data</span><span class="p">(</span>
+            <span class="bp">self</span><span class="o">.</span><span class="n">fieldbus_handle</span>
+        <span class="p">)</span></div>
+
+<div class="viewcode-block" id="GHS.ghs_read_next_snapshot"><a class="viewcode-back" href="../../fieldbus.html#ghsapi.ghsapi.GHS.ghs_read_next_snapshot">[docs]</a>    <span class="k">def</span> <span class="nf">ghs_read_next_snapshot</span><span class="p">(</span>
+        <span class="bp">self</span><span class="p">,</span>
+        <span class="n">call_type</span><span class="p">:</span> <span class="nb">str</span> <span class="o">|</span> <span class="nb">int</span>
+    <span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">tuple</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="nb">float</span> <span class="o">|</span> <span class="kc">None</span><span class="p">,</span> <span class="nb">float</span> <span class="o">|</span> <span class="kc">None</span><span class="p">,</span> <span class="nb">int</span> <span class="o">|</span> <span class="kc">None</span><span class="p">]:</span>
+<span class="w">        </span><span class="sd">&quot;&quot;&quot;Retrieves the next snapshot in the buffer.</span>
+
+<span class="sd">        *The timestamp is grid aligned - as specified by the &#39;updateRate&#39; argument</span>
+<span class="sd">        of the GHSInitiateFieldBusDataTransfer() method.*</span>
+
+<span class="sd">        Args:</span>
+<span class="sd">            call_type: flag to control the receiving of FieldBus data:</span>
+<span class="sd">                        *If set to GHS_BlockingCall it blocks while waiting for new FieldBus data.</span>
+<span class="sd">                        *If set to GHS_NonBlockingCall then returns last FieldBus data when no new data available.</span>
+<span class="sd">                        *GHS_BlockingCall is the preferred value as this results in the lowest CPU load</span>
+<span class="sd">                        and highest data troughput.*</span>
+
+<span class="sd">        Returns:</span>
+<span class="sd">            * GHSReturnValue - API return values</span>
+<span class="sd">            * Timestamp - timestamp of the FieldBus data relative to start of acquisition GHSGetAcquisitionStartTime()</span>
+<span class="sd">            * Values - the values published on the FieldBus.</span>
+<span class="sd">            * Overrun - is one if overrun happened in the buffer, zero if not.</span>
+<span class="sd">        &quot;&quot;&quot;</span>
+
+        <span class="k">return</span> <span class="n">_fieldbus</span><span class="o">.</span><span class="n">read_next_snapshot</span><span class="p">(</span>
+            <span class="bp">self</span><span class="o">.</span><span class="n">fieldbus_handle</span><span class="p">,</span>
+            <span class="n">call_type</span>
+        <span class="p">)</span></div>
 </pre></div>
 
            </div>
diff --git a/docs/html/_modules/index.html b/docs/html/_modules/index.html
index 1f49491..5977efd 100644
--- a/docs/html/_modules/index.html
+++ b/docs/html/_modules/index.html
@@ -10,10 +10,11 @@
     <script src="../_static/js/html5shiv.min.js"></script>
   <![endif]-->
   
-        <script data-url_root="../" id="documentation_options" src="../_static/documentation_options.js"></script>
         <script src="../_static/jquery.js"></script>
-        <script src="../_static/underscore.js"></script>
+        <script src="../_static/_sphinx_javascript_frameworks_compat.js"></script>
+        <script data-url_root="../" id="documentation_options" src="../_static/documentation_options.js"></script>
         <script src="../_static/doctools.js"></script>
+        <script src="../_static/sphinx_highlight.js"></script>
     <script src="../_static/js/theme.js"></script>
     <link rel="index" title="Index" href="../genindex.html" />
     <link rel="search" title="Search" href="../search.html" /> 
@@ -24,11 +25,15 @@
     <nav data-toggle="wy-nav-shift" class="wy-nav-side">
       <div class="wy-side-scroll">
         <div class="wy-side-nav-search" >
-            <a href="../index.html" class="icon icon-home"> GEN DAQ API - Python Driver
+
+          
+          
+          <a href="../index.html" class="icon icon-home">
+            GEN DAQ API - Python Driver
           </a>
 <div role="search">
   <form id="rtd-search-form" class="wy-form" action="../search.html" method="get">
-    <input type="text" name="q" placeholder="Search docs" />
+    <input type="text" name="q" placeholder="Search docs" aria-label="Search docs" />
     <input type="hidden" name="check_keywords" value="yes" />
     <input type="hidden" name="area" value="default" />
   </form>
@@ -54,8 +59,8 @@
         <div class="rst-content">
           <div role="navigation" aria-label="Page navigation">
   <ul class="wy-breadcrumbs">
-      <li><a href="../index.html" class="icon icon-home"></a> &raquo;</li>
-      <li>Overview: module code</li>
+      <li><a href="../index.html" class="icon icon-home" aria-label="Home"></a></li>
+      <li class="breadcrumb-item active">Overview: module code</li>
       <li class="wy-breadcrumbs-aside">
       </li>
   </ul>
diff --git a/docs/html/_sources/fieldbus.rst.txt b/docs/html/_sources/fieldbus.rst.txt
new file mode 100644
index 0000000..617273e
--- /dev/null
+++ b/docs/html/_sources/fieldbus.rst.txt
@@ -0,0 +1,12 @@
+FieldBus
+===========
+
+FieldBus related API functions.
+
+.. automethod:: ghsapi.ghsapi.GHS.ghs_get_fieldbus_data_count
+.. automethod:: ghsapi.ghsapi.GHS.ghs_get_fieldbus_data_name_and_unit
+.. automethod:: ghsapi.ghsapi.GHS.ghs_initiate_fieldbus_data_transfer
+.. automethod:: ghsapi.ghsapi.GHS.ghs_stop_fieldbus_data_transfer
+.. automethod:: ghsapi.ghsapi.GHS.ghs_receive_fieldbus_data
+.. automethod:: ghsapi.ghsapi.GHS.ghs_read_next_snapshot
+.. automethod:: ghsapi.ghsapi.GHS.ghs_request_fieldbus_snapshot
\ No newline at end of file
diff --git a/docs/html/_sources/ghspyapi.rst.txt b/docs/html/_sources/ghspyapi.rst.txt
index fcb9195..c242261 100644
--- a/docs/html/_sources/ghspyapi.rst.txt
+++ b/docs/html/_sources/ghspyapi.rst.txt
@@ -13,3 +13,4 @@ All available API functions:
    managemainframe
    recorder
    channel
+   fieldbus
\ No newline at end of file
diff --git a/docs/html/_static/_sphinx_javascript_frameworks_compat.js b/docs/html/_static/_sphinx_javascript_frameworks_compat.js
new file mode 100644
index 0000000..8141580
--- /dev/null
+++ b/docs/html/_static/_sphinx_javascript_frameworks_compat.js
@@ -0,0 +1,123 @@
+/* Compatability shim for jQuery and underscores.js.
+ *
+ * Copyright Sphinx contributors
+ * Released under the two clause BSD licence
+ */
+
+/**
+ * small helper function to urldecode strings
+ *
+ * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/decodeURIComponent#Decoding_query_parameters_from_a_URL
+ */
+jQuery.urldecode = function(x) {
+    if (!x) {
+        return x
+    }
+    return decodeURIComponent(x.replace(/\+/g, ' '));
+};
+
+/**
+ * small helper function to urlencode strings
+ */
+jQuery.urlencode = encodeURIComponent;
+
+/**
+ * This function returns the parsed url parameters of the
+ * current request. Multiple values per key are supported,
+ * it will always return arrays of strings for the value parts.
+ */
+jQuery.getQueryParameters = function(s) {
+    if (typeof s === 'undefined')
+        s = document.location.search;
+    var parts = s.substr(s.indexOf('?') + 1).split('&');
+    var result = {};
+    for (var i = 0; i < parts.length; i++) {
+        var tmp = parts[i].split('=', 2);
+        var key = jQuery.urldecode(tmp[0]);
+        var value = jQuery.urldecode(tmp[1]);
+        if (key in result)
+            result[key].push(value);
+        else
+            result[key] = [value];
+    }
+    return result;
+};
+
+/**
+ * highlight a given string on a jquery object by wrapping it in
+ * span elements with the given class name.
+ */
+jQuery.fn.highlightText = function(text, className) {
+    function highlight(node, addItems) {
+        if (node.nodeType === 3) {
+            var val = node.nodeValue;
+            var pos = val.toLowerCase().indexOf(text);
+            if (pos >= 0 &&
+                !jQuery(node.parentNode).hasClass(className) &&
+                !jQuery(node.parentNode).hasClass("nohighlight")) {
+                var span;
+                var isInSVG = jQuery(node).closest("body, svg, foreignObject").is("svg");
+                if (isInSVG) {
+                    span = document.createElementNS("http://www.w3.org/2000/svg", "tspan");
+                } else {
+                    span = document.createElement("span");
+                    span.className = className;
+                }
+                span.appendChild(document.createTextNode(val.substr(pos, text.length)));
+                node.parentNode.insertBefore(span, node.parentNode.insertBefore(
+                    document.createTextNode(val.substr(pos + text.length)),
+                    node.nextSibling));
+                node.nodeValue = val.substr(0, pos);
+                if (isInSVG) {
+                    var rect = document.createElementNS("http://www.w3.org/2000/svg", "rect");
+                    var bbox = node.parentElement.getBBox();
+                    rect.x.baseVal.value = bbox.x;
+                    rect.y.baseVal.value = bbox.y;
+                    rect.width.baseVal.value = bbox.width;
+                    rect.height.baseVal.value = bbox.height;
+                    rect.setAttribute('class', className);
+                    addItems.push({
+                        "parent": node.parentNode,
+                        "target": rect});
+                }
+            }
+        }
+        else if (!jQuery(node).is("button, select, textarea")) {
+            jQuery.each(node.childNodes, function() {
+                highlight(this, addItems);
+            });
+        }
+    }
+    var addItems = [];
+    var result = this.each(function() {
+        highlight(this, addItems);
+    });
+    for (var i = 0; i < addItems.length; ++i) {
+        jQuery(addItems[i].parent).before(addItems[i].target);
+    }
+    return result;
+};
+
+/*
+ * backward compatibility for jQuery.browser
+ * This will be supported until firefox bug is fixed.
+ */
+if (!jQuery.browser) {
+    jQuery.uaMatch = function(ua) {
+        ua = ua.toLowerCase();
+
+        var match = /(chrome)[ \/]([\w.]+)/.exec(ua) ||
+            /(webkit)[ \/]([\w.]+)/.exec(ua) ||
+            /(opera)(?:.*version|)[ \/]([\w.]+)/.exec(ua) ||
+            /(msie) ([\w.]+)/.exec(ua) ||
+            ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(ua) ||
+            [];
+
+        return {
+            browser: match[ 1 ] || "",
+            version: match[ 2 ] || "0"
+        };
+    };
+    jQuery.browser = {};
+    jQuery.browser[jQuery.uaMatch(navigator.userAgent).browser] = true;
+}
diff --git a/docs/html/_static/basic.css b/docs/html/_static/basic.css
index bf18350..7577acb 100644
--- a/docs/html/_static/basic.css
+++ b/docs/html/_static/basic.css
@@ -4,7 +4,7 @@
  *
  * Sphinx stylesheet -- basic theme.
  *
- * :copyright: Copyright 2007-2022 by the Sphinx team, see AUTHORS.
+ * :copyright: Copyright 2007-2023 by the Sphinx team, see AUTHORS.
  * :license: BSD, see LICENSE for details.
  *
  */
@@ -222,7 +222,7 @@ table.modindextable td {
 /* -- general body styles --------------------------------------------------- */
 
 div.body {
-    min-width: 450px;
+    min-width: 360px;
     max-width: 800px;
 }
 
@@ -237,16 +237,6 @@ a.headerlink {
     visibility: hidden;
 }
 
-a.brackets:before,
-span.brackets > a:before{
-    content: "[";
-}
-
-a.brackets:after,
-span.brackets > a:after {
-    content: "]";
-}
-
 h1:hover > a.headerlink,
 h2:hover > a.headerlink,
 h3:hover > a.headerlink,
@@ -335,12 +325,16 @@ p.sidebar-title {
     font-weight: bold;
 }
 
+nav.contents,
+aside.topic,
 div.admonition, div.topic, blockquote {
     clear: left;
 }
 
 /* -- topics ---------------------------------------------------------------- */
 
+nav.contents,
+aside.topic,
 div.topic {
     border: 1px solid #ccc;
     padding: 7px;
@@ -379,6 +373,8 @@ div.body p.centered {
 
 div.sidebar > :last-child,
 aside.sidebar > :last-child,
+nav.contents > :last-child,
+aside.topic > :last-child,
 div.topic > :last-child,
 div.admonition > :last-child {
     margin-bottom: 0;
@@ -386,6 +382,8 @@ div.admonition > :last-child {
 
 div.sidebar::after,
 aside.sidebar::after,
+nav.contents::after,
+aside.topic::after,
 div.topic::after,
 div.admonition::after,
 blockquote::after {
@@ -428,10 +426,6 @@ table.docutils td, table.docutils th {
     border-bottom: 1px solid #aaa;
 }
 
-table.footnote td, table.footnote th {
-    border: 0 !important;
-}
-
 th {
     text-align: left;
     padding-right: 5px;
@@ -615,19 +609,26 @@ ul.simple p {
     margin-bottom: 0;
 }
 
-dl.footnote > dt,
-dl.citation > dt {
+aside.footnote > span,
+div.citation > span {
     float: left;
-    margin-right: 0.5em;
 }
-
-dl.footnote > dd,
-dl.citation > dd {
+aside.footnote > span:last-of-type,
+div.citation > span:last-of-type {
+  padding-right: 0.5em;
+}
+aside.footnote > p {
+  margin-left: 2em;
+}
+div.citation > p {
+  margin-left: 4em;
+}
+aside.footnote > p:last-of-type,
+div.citation > p:last-of-type {
     margin-bottom: 0em;
 }
-
-dl.footnote > dd:after,
-dl.citation > dd:after {
+aside.footnote > p:last-of-type:after,
+div.citation > p:last-of-type:after {
     content: "";
     clear: both;
 }
@@ -644,10 +645,6 @@ dl.field-list > dt {
     padding-right: 5px;
 }
 
-dl.field-list > dt:after {
-    content: ":";
-}
-
 dl.field-list > dd {
     padding-left: 0.5em;
     margin-top: 0em;
diff --git a/docs/html/_static/css/badge_only.css b/docs/html/_static/css/badge_only.css
index e380325..c718cee 100644
--- a/docs/html/_static/css/badge_only.css
+++ b/docs/html/_static/css/badge_only.css
@@ -1 +1 @@
-.fa:before{-webkit-font-smoothing:antialiased}.clearfix{*zoom:1}.clearfix:after,.clearfix:before{display:table;content:""}.clearfix:after{clear:both}@font-face{font-family:FontAwesome;font-style:normal;font-weight:400;src:url(fonts/fontawesome-webfont.eot?674f50d287a8c48dc19ba404d20fe713?#iefix) format("embedded-opentype"),url(fonts/fontawesome-webfont.woff2?af7ae505a9eed503f8b8e6982036873e) format("woff2"),url(fonts/fontawesome-webfont.woff?fee66e712a8a08eef5805a46892932ad) format("woff"),url(fonts/fontawesome-webfont.ttf?b06871f281fee6b241d60582ae9369b9) format("truetype"),url(fonts/fontawesome-webfont.svg?912ec66d7572ff821749319396470bde#FontAwesome) format("svg")}.fa:before{font-family:FontAwesome;font-style:normal;font-weight:400;line-height:1}.fa:before,a .fa{text-decoration:inherit}.fa:before,a .fa,li .fa{display:inline-block}li .fa-large:before{width:1.875em}ul.fas{list-style-type:none;margin-left:2em;text-indent:-.8em}ul.fas li .fa{width:.8em}ul.fas li .fa-large:before{vertical-align:baseline}.fa-book:before,.icon-book:before{content:"\f02d"}.fa-caret-down:before,.icon-caret-down:before{content:"\f0d7"}.fa-caret-up:before,.icon-caret-up:before{content:"\f0d8"}.fa-caret-left:before,.icon-caret-left:before{content:"\f0d9"}.fa-caret-right:before,.icon-caret-right:before{content:"\f0da"}.rst-versions{position:fixed;bottom:0;left:0;width:300px;color:#fcfcfc;background:#1f1d1d;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;z-index:400}.rst-versions a{color:#2980b9;text-decoration:none}.rst-versions .rst-badge-small{display:none}.rst-versions .rst-current-version{padding:12px;background-color:#272525;display:block;text-align:right;font-size:90%;cursor:pointer;color:#27ae60}.rst-versions .rst-current-version:after{clear:both;content:"";display:block}.rst-versions .rst-current-version .fa{color:#fcfcfc}.rst-versions .rst-current-version .fa-book,.rst-versions .rst-current-version .icon-book{float:left}.rst-versions .rst-current-version.rst-out-of-date{background-color:#e74c3c;color:#fff}.rst-versions .rst-current-version.rst-active-old-version{background-color:#f1c40f;color:#000}.rst-versions.shift-up{height:auto;max-height:100%;overflow-y:scroll}.rst-versions.shift-up .rst-other-versions{display:block}.rst-versions .rst-other-versions{font-size:90%;padding:12px;color:grey;display:none}.rst-versions .rst-other-versions hr{display:block;height:1px;border:0;margin:20px 0;padding:0;border-top:1px solid #413d3d}.rst-versions .rst-other-versions dd{display:inline-block;margin:0}.rst-versions .rst-other-versions dd a{display:inline-block;padding:6px;color:#fcfcfc}.rst-versions.rst-badge{width:auto;bottom:20px;right:20px;left:auto;border:none;max-width:300px;max-height:90%}.rst-versions.rst-badge .fa-book,.rst-versions.rst-badge .icon-book{float:none;line-height:30px}.rst-versions.rst-badge.shift-up .rst-current-version{text-align:right}.rst-versions.rst-badge.shift-up .rst-current-version .fa-book,.rst-versions.rst-badge.shift-up .rst-current-version .icon-book{float:left}.rst-versions.rst-badge>.rst-current-version{width:auto;height:30px;line-height:30px;padding:0 6px;display:block;text-align:center}@media screen and (max-width:768px){.rst-versions{width:85%;display:none}.rst-versions.shift{display:block}}
\ No newline at end of file
+.clearfix{*zoom:1}.clearfix:after,.clearfix:before{display:table;content:""}.clearfix:after{clear:both}@font-face{font-family:FontAwesome;font-style:normal;font-weight:400;src:url(fonts/fontawesome-webfont.eot?674f50d287a8c48dc19ba404d20fe713?#iefix) format("embedded-opentype"),url(fonts/fontawesome-webfont.woff2?af7ae505a9eed503f8b8e6982036873e) format("woff2"),url(fonts/fontawesome-webfont.woff?fee66e712a8a08eef5805a46892932ad) format("woff"),url(fonts/fontawesome-webfont.ttf?b06871f281fee6b241d60582ae9369b9) format("truetype"),url(fonts/fontawesome-webfont.svg?912ec66d7572ff821749319396470bde#FontAwesome) format("svg")}.fa:before{font-family:FontAwesome;font-style:normal;font-weight:400;line-height:1}.fa:before,a .fa{text-decoration:inherit}.fa:before,a .fa,li .fa{display:inline-block}li .fa-large:before{width:1.875em}ul.fas{list-style-type:none;margin-left:2em;text-indent:-.8em}ul.fas li .fa{width:.8em}ul.fas li .fa-large:before{vertical-align:baseline}.fa-book:before,.icon-book:before{content:"\f02d"}.fa-caret-down:before,.icon-caret-down:before{content:"\f0d7"}.fa-caret-up:before,.icon-caret-up:before{content:"\f0d8"}.fa-caret-left:before,.icon-caret-left:before{content:"\f0d9"}.fa-caret-right:before,.icon-caret-right:before{content:"\f0da"}.rst-versions{position:fixed;bottom:0;left:0;width:300px;color:#fcfcfc;background:#1f1d1d;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;z-index:400}.rst-versions a{color:#2980b9;text-decoration:none}.rst-versions .rst-badge-small{display:none}.rst-versions .rst-current-version{padding:12px;background-color:#272525;display:block;text-align:right;font-size:90%;cursor:pointer;color:#27ae60}.rst-versions .rst-current-version:after{clear:both;content:"";display:block}.rst-versions .rst-current-version .fa{color:#fcfcfc}.rst-versions .rst-current-version .fa-book,.rst-versions .rst-current-version .icon-book{float:left}.rst-versions .rst-current-version.rst-out-of-date{background-color:#e74c3c;color:#fff}.rst-versions .rst-current-version.rst-active-old-version{background-color:#f1c40f;color:#000}.rst-versions.shift-up{height:auto;max-height:100%;overflow-y:scroll}.rst-versions.shift-up .rst-other-versions{display:block}.rst-versions .rst-other-versions{font-size:90%;padding:12px;color:grey;display:none}.rst-versions .rst-other-versions hr{display:block;height:1px;border:0;margin:20px 0;padding:0;border-top:1px solid #413d3d}.rst-versions .rst-other-versions dd{display:inline-block;margin:0}.rst-versions .rst-other-versions dd a{display:inline-block;padding:6px;color:#fcfcfc}.rst-versions.rst-badge{width:auto;bottom:20px;right:20px;left:auto;border:none;max-width:300px;max-height:90%}.rst-versions.rst-badge .fa-book,.rst-versions.rst-badge .icon-book{float:none;line-height:30px}.rst-versions.rst-badge.shift-up .rst-current-version{text-align:right}.rst-versions.rst-badge.shift-up .rst-current-version .fa-book,.rst-versions.rst-badge.shift-up .rst-current-version .icon-book{float:left}.rst-versions.rst-badge>.rst-current-version{width:auto;height:30px;line-height:30px;padding:0 6px;display:block;text-align:center}@media screen and (max-width:768px){.rst-versions{width:85%;display:none}.rst-versions.shift{display:block}}
\ No newline at end of file
diff --git a/docs/html/_static/css/theme.css b/docs/html/_static/css/theme.css
index 0d9ae7e..19a446a 100644
--- a/docs/html/_static/css/theme.css
+++ b/docs/html/_static/css/theme.css
@@ -1,4 +1,4 @@
-html{box-sizing:border-box}*,:after,:before{box-sizing:inherit}article,aside,details,figcaption,figure,footer,header,hgroup,nav,section{display:block}audio,canvas,video{display:inline-block;*display:inline;*zoom:1}[hidden],audio:not([controls]){display:none}*{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}html{font-size:100%;-webkit-text-size-adjust:100%;-ms-text-size-adjust:100%}body{margin:0}a:active,a:hover{outline:0}abbr[title]{border-bottom:1px dotted}b,strong{font-weight:700}blockquote{margin:0}dfn{font-style:italic}ins{background:#ff9;text-decoration:none}ins,mark{color:#000}mark{background:#ff0;font-style:italic;font-weight:700}.rst-content code,.rst-content tt,code,kbd,pre,samp{font-family:monospace,serif;_font-family:courier new,monospace;font-size:1em}pre{white-space:pre}q{quotes:none}q:after,q:before{content:"";content:none}small{font-size:85%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sup{top:-.5em}sub{bottom:-.25em}dl,ol,ul{margin:0;padding:0;list-style:none;list-style-image:none}li{list-style:none}dd{margin:0}img{border:0;-ms-interpolation-mode:bicubic;vertical-align:middle;max-width:100%}svg:not(:root){overflow:hidden}figure,form{margin:0}label{cursor:pointer}button,input,select,textarea{font-size:100%;margin:0;vertical-align:baseline;*vertical-align:middle}button,input{line-height:normal}button,input[type=button],input[type=reset],input[type=submit]{cursor:pointer;-webkit-appearance:button;*overflow:visible}button[disabled],input[disabled]{cursor:default}input[type=search]{-webkit-appearance:textfield;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;box-sizing:content-box}textarea{resize:vertical}table{border-collapse:collapse;border-spacing:0}td{vertical-align:top}.chromeframe{margin:.2em 0;background:#ccc;color:#000;padding:.2em 0}.ir{display:block;border:0;text-indent:-999em;overflow:hidden;background-color:transparent;background-repeat:no-repeat;text-align:left;direction:ltr;*line-height:0}.ir br{display:none}.hidden{display:none!important;visibility:hidden}.visuallyhidden{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px}.visuallyhidden.focusable:active,.visuallyhidden.focusable:focus{clip:auto;height:auto;margin:0;overflow:visible;position:static;width:auto}.invisible{visibility:hidden}.relative{position:relative}big,small{font-size:100%}@media print{body,html,section{background:none!important}*{box-shadow:none!important;text-shadow:none!important;filter:none!important;-ms-filter:none!important}a,a:visited{text-decoration:underline}.ir a:after,a[href^="#"]:after,a[href^="javascript:"]:after{content:""}blockquote,pre{page-break-inside:avoid}thead{display:table-header-group}img,tr{page-break-inside:avoid}img{max-width:100%!important}@page{margin:.5cm}.rst-content .toctree-wrapper>p.caption,h2,h3,p{orphans:3;widows:3}.rst-content .toctree-wrapper>p.caption,h2,h3{page-break-after:avoid}}.btn,.fa:before,.icon:before,.rst-content .admonition,.rst-content .admonition-title:before,.rst-content .admonition-todo,.rst-content .attention,.rst-content .caution,.rst-content .code-block-caption .headerlink:before,.rst-content .danger,.rst-content .eqno .headerlink:before,.rst-content .error,.rst-content .hint,.rst-content .important,.rst-content .note,.rst-content .seealso,.rst-content .tip,.rst-content .warning,.rst-content code.download span:first-child:before,.rst-content dl dt .headerlink:before,.rst-content h1 .headerlink:before,.rst-content h2 .headerlink:before,.rst-content h3 .headerlink:before,.rst-content h4 .headerlink:before,.rst-content h5 .headerlink:before,.rst-content h6 .headerlink:before,.rst-content p.caption .headerlink:before,.rst-content p .headerlink:before,.rst-content table>caption .headerlink:before,.rst-content tt.download span:first-child:before,.wy-alert,.wy-dropdown .caret:before,.wy-inline-validate.wy-inline-validate-danger .wy-input-context:before,.wy-inline-validate.wy-inline-validate-info .wy-input-context:before,.wy-inline-validate.wy-inline-validate-success .wy-input-context:before,.wy-inline-validate.wy-inline-validate-warning .wy-input-context:before,.wy-menu-vertical li.current>a,.wy-menu-vertical li.current>a button.toctree-expand:before,.wy-menu-vertical li.on a,.wy-menu-vertical li.on a button.toctree-expand:before,.wy-menu-vertical li button.toctree-expand:before,.wy-nav-top a,.wy-side-nav-search .wy-dropdown>a,.wy-side-nav-search>a,input[type=color],input[type=date],input[type=datetime-local],input[type=datetime],input[type=email],input[type=month],input[type=number],input[type=password],input[type=search],input[type=tel],input[type=text],input[type=time],input[type=url],input[type=week],select,textarea{-webkit-font-smoothing:antialiased}.clearfix{*zoom:1}.clearfix:after,.clearfix:before{display:table;content:""}.clearfix:after{clear:both}/*!
+html{box-sizing:border-box}*,:after,:before{box-sizing:inherit}article,aside,details,figcaption,figure,footer,header,hgroup,nav,section{display:block}audio,canvas,video{display:inline-block;*display:inline;*zoom:1}[hidden],audio:not([controls]){display:none}*{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}html{font-size:100%;-webkit-text-size-adjust:100%;-ms-text-size-adjust:100%}body{margin:0}a:active,a:hover{outline:0}abbr[title]{border-bottom:1px dotted}b,strong{font-weight:700}blockquote{margin:0}dfn{font-style:italic}ins{background:#ff9;text-decoration:none}ins,mark{color:#000}mark{background:#ff0;font-style:italic;font-weight:700}.rst-content code,.rst-content tt,code,kbd,pre,samp{font-family:monospace,serif;_font-family:courier new,monospace;font-size:1em}pre{white-space:pre}q{quotes:none}q:after,q:before{content:"";content:none}small{font-size:85%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sup{top:-.5em}sub{bottom:-.25em}dl,ol,ul{margin:0;padding:0;list-style:none;list-style-image:none}li{list-style:none}dd{margin:0}img{border:0;-ms-interpolation-mode:bicubic;vertical-align:middle;max-width:100%}svg:not(:root){overflow:hidden}figure,form{margin:0}label{cursor:pointer}button,input,select,textarea{font-size:100%;margin:0;vertical-align:baseline;*vertical-align:middle}button,input{line-height:normal}button,input[type=button],input[type=reset],input[type=submit]{cursor:pointer;-webkit-appearance:button;*overflow:visible}button[disabled],input[disabled]{cursor:default}input[type=search]{-webkit-appearance:textfield;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;box-sizing:content-box}textarea{resize:vertical}table{border-collapse:collapse;border-spacing:0}td{vertical-align:top}.chromeframe{margin:.2em 0;background:#ccc;color:#000;padding:.2em 0}.ir{display:block;border:0;text-indent:-999em;overflow:hidden;background-color:transparent;background-repeat:no-repeat;text-align:left;direction:ltr;*line-height:0}.ir br{display:none}.hidden{display:none!important;visibility:hidden}.visuallyhidden{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px}.visuallyhidden.focusable:active,.visuallyhidden.focusable:focus{clip:auto;height:auto;margin:0;overflow:visible;position:static;width:auto}.invisible{visibility:hidden}.relative{position:relative}big,small{font-size:100%}@media print{body,html,section{background:none!important}*{box-shadow:none!important;text-shadow:none!important;filter:none!important;-ms-filter:none!important}a,a:visited{text-decoration:underline}.ir a:after,a[href^="#"]:after,a[href^="javascript:"]:after{content:""}blockquote,pre{page-break-inside:avoid}thead{display:table-header-group}img,tr{page-break-inside:avoid}img{max-width:100%!important}@page{margin:.5cm}.rst-content .toctree-wrapper>p.caption,h2,h3,p{orphans:3;widows:3}.rst-content .toctree-wrapper>p.caption,h2,h3{page-break-after:avoid}}.btn,.fa:before,.icon:before,.rst-content .admonition,.rst-content .admonition-title:before,.rst-content .admonition-todo,.rst-content .attention,.rst-content .caution,.rst-content .code-block-caption .headerlink:before,.rst-content .danger,.rst-content .eqno .headerlink:before,.rst-content .error,.rst-content .hint,.rst-content .important,.rst-content .note,.rst-content .seealso,.rst-content .tip,.rst-content .warning,.rst-content code.download span:first-child:before,.rst-content dl dt .headerlink:before,.rst-content h1 .headerlink:before,.rst-content h2 .headerlink:before,.rst-content h3 .headerlink:before,.rst-content h4 .headerlink:before,.rst-content h5 .headerlink:before,.rst-content h6 .headerlink:before,.rst-content p.caption .headerlink:before,.rst-content p .headerlink:before,.rst-content table>caption .headerlink:before,.rst-content tt.download span:first-child:before,.wy-alert,.wy-dropdown .caret:before,.wy-inline-validate.wy-inline-validate-danger .wy-input-context:before,.wy-inline-validate.wy-inline-validate-info .wy-input-context:before,.wy-inline-validate.wy-inline-validate-success .wy-input-context:before,.wy-inline-validate.wy-inline-validate-warning .wy-input-context:before,.wy-menu-vertical li.current>a button.toctree-expand:before,.wy-menu-vertical li.on a button.toctree-expand:before,.wy-menu-vertical li button.toctree-expand:before,input[type=color],input[type=date],input[type=datetime-local],input[type=datetime],input[type=email],input[type=month],input[type=number],input[type=password],input[type=search],input[type=tel],input[type=text],input[type=time],input[type=url],input[type=week],select,textarea{-webkit-font-smoothing:antialiased}.clearfix{*zoom:1}.clearfix:after,.clearfix:before{display:table;content:""}.clearfix:after{clear:both}/*!
  *  Font Awesome 4.7.0 by @davegandy - http://fontawesome.io - @fontawesome
  *  License - http://fontawesome.io/license (Font: SIL OFL 1.1, CSS: MIT License)
- */@font-face{font-family:FontAwesome;src:url(fonts/fontawesome-webfont.eot?674f50d287a8c48dc19ba404d20fe713);src:url(fonts/fontawesome-webfont.eot?674f50d287a8c48dc19ba404d20fe713?#iefix&v=4.7.0) format("embedded-opentype"),url(fonts/fontawesome-webfont.woff2?af7ae505a9eed503f8b8e6982036873e) format("woff2"),url(fonts/fontawesome-webfont.woff?fee66e712a8a08eef5805a46892932ad) format("woff"),url(fonts/fontawesome-webfont.ttf?b06871f281fee6b241d60582ae9369b9) format("truetype"),url(fonts/fontawesome-webfont.svg?912ec66d7572ff821749319396470bde#fontawesomeregular) format("svg");font-weight:400;font-style:normal}.fa,.icon,.rst-content .admonition-title,.rst-content .code-block-caption .headerlink,.rst-content .eqno .headerlink,.rst-content code.download span:first-child,.rst-content dl dt .headerlink,.rst-content h1 .headerlink,.rst-content h2 .headerlink,.rst-content h3 .headerlink,.rst-content h4 .headerlink,.rst-content h5 .headerlink,.rst-content h6 .headerlink,.rst-content p.caption .headerlink,.rst-content p .headerlink,.rst-content table>caption .headerlink,.rst-content tt.download span:first-child,.wy-menu-vertical li.current>a button.toctree-expand,.wy-menu-vertical li.on a button.toctree-expand,.wy-menu-vertical li button.toctree-expand{display:inline-block;font:normal normal normal 14px/1 FontAwesome;font-size:inherit;text-rendering:auto;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}.fa-lg{font-size:1.33333em;line-height:.75em;vertical-align:-15%}.fa-2x{font-size:2em}.fa-3x{font-size:3em}.fa-4x{font-size:4em}.fa-5x{font-size:5em}.fa-fw{width:1.28571em;text-align:center}.fa-ul{padding-left:0;margin-left:2.14286em;list-style-type:none}.fa-ul>li{position:relative}.fa-li{position:absolute;left:-2.14286em;width:2.14286em;top:.14286em;text-align:center}.fa-li.fa-lg{left:-1.85714em}.fa-border{padding:.2em .25em .15em;border:.08em solid #eee;border-radius:.1em}.fa-pull-left{float:left}.fa-pull-right{float:right}.fa-pull-left.icon,.fa.fa-pull-left,.rst-content .code-block-caption .fa-pull-left.headerlink,.rst-content .eqno .fa-pull-left.headerlink,.rst-content .fa-pull-left.admonition-title,.rst-content code.download span.fa-pull-left:first-child,.rst-content dl dt .fa-pull-left.headerlink,.rst-content h1 .fa-pull-left.headerlink,.rst-content h2 .fa-pull-left.headerlink,.rst-content h3 .fa-pull-left.headerlink,.rst-content h4 .fa-pull-left.headerlink,.rst-content h5 .fa-pull-left.headerlink,.rst-content h6 .fa-pull-left.headerlink,.rst-content p .fa-pull-left.headerlink,.rst-content table>caption .fa-pull-left.headerlink,.rst-content tt.download span.fa-pull-left:first-child,.wy-menu-vertical li.current>a button.fa-pull-left.toctree-expand,.wy-menu-vertical li.on a button.fa-pull-left.toctree-expand,.wy-menu-vertical li button.fa-pull-left.toctree-expand{margin-right:.3em}.fa-pull-right.icon,.fa.fa-pull-right,.rst-content .code-block-caption .fa-pull-right.headerlink,.rst-content .eqno .fa-pull-right.headerlink,.rst-content .fa-pull-right.admonition-title,.rst-content code.download span.fa-pull-right:first-child,.rst-content dl dt .fa-pull-right.headerlink,.rst-content h1 .fa-pull-right.headerlink,.rst-content h2 .fa-pull-right.headerlink,.rst-content h3 .fa-pull-right.headerlink,.rst-content h4 .fa-pull-right.headerlink,.rst-content h5 .fa-pull-right.headerlink,.rst-content h6 .fa-pull-right.headerlink,.rst-content p .fa-pull-right.headerlink,.rst-content table>caption .fa-pull-right.headerlink,.rst-content tt.download span.fa-pull-right:first-child,.wy-menu-vertical li.current>a button.fa-pull-right.toctree-expand,.wy-menu-vertical li.on a button.fa-pull-right.toctree-expand,.wy-menu-vertical li button.fa-pull-right.toctree-expand{margin-left:.3em}.pull-right{float:right}.pull-left{float:left}.fa.pull-left,.pull-left.icon,.rst-content .code-block-caption .pull-left.headerlink,.rst-content .eqno .pull-left.headerlink,.rst-content .pull-left.admonition-title,.rst-content code.download span.pull-left:first-child,.rst-content dl dt .pull-left.headerlink,.rst-content h1 .pull-left.headerlink,.rst-content h2 .pull-left.headerlink,.rst-content h3 .pull-left.headerlink,.rst-content h4 .pull-left.headerlink,.rst-content h5 .pull-left.headerlink,.rst-content h6 .pull-left.headerlink,.rst-content p .pull-left.headerlink,.rst-content table>caption .pull-left.headerlink,.rst-content tt.download span.pull-left:first-child,.wy-menu-vertical li.current>a button.pull-left.toctree-expand,.wy-menu-vertical li.on a button.pull-left.toctree-expand,.wy-menu-vertical li button.pull-left.toctree-expand{margin-right:.3em}.fa.pull-right,.pull-right.icon,.rst-content .code-block-caption .pull-right.headerlink,.rst-content .eqno .pull-right.headerlink,.rst-content .pull-right.admonition-title,.rst-content code.download span.pull-right:first-child,.rst-content dl dt .pull-right.headerlink,.rst-content h1 .pull-right.headerlink,.rst-content h2 .pull-right.headerlink,.rst-content h3 .pull-right.headerlink,.rst-content h4 .pull-right.headerlink,.rst-content h5 .pull-right.headerlink,.rst-content h6 .pull-right.headerlink,.rst-content p .pull-right.headerlink,.rst-content table>caption .pull-right.headerlink,.rst-content tt.download span.pull-right:first-child,.wy-menu-vertical li.current>a button.pull-right.toctree-expand,.wy-menu-vertical li.on a button.pull-right.toctree-expand,.wy-menu-vertical li button.pull-right.toctree-expand{margin-left:.3em}.fa-spin{-webkit-animation:fa-spin 2s linear infinite;animation:fa-spin 2s linear infinite}.fa-pulse{-webkit-animation:fa-spin 1s steps(8) infinite;animation:fa-spin 1s steps(8) infinite}@-webkit-keyframes fa-spin{0%{-webkit-transform:rotate(0deg);transform:rotate(0deg)}to{-webkit-transform:rotate(359deg);transform:rotate(359deg)}}@keyframes fa-spin{0%{-webkit-transform:rotate(0deg);transform:rotate(0deg)}to{-webkit-transform:rotate(359deg);transform:rotate(359deg)}}.fa-rotate-90{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=1)";-webkit-transform:rotate(90deg);-ms-transform:rotate(90deg);transform:rotate(90deg)}.fa-rotate-180{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=2)";-webkit-transform:rotate(180deg);-ms-transform:rotate(180deg);transform:rotate(180deg)}.fa-rotate-270{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=3)";-webkit-transform:rotate(270deg);-ms-transform:rotate(270deg);transform:rotate(270deg)}.fa-flip-horizontal{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=0, mirror=1)";-webkit-transform:scaleX(-1);-ms-transform:scaleX(-1);transform:scaleX(-1)}.fa-flip-vertical{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1)";-webkit-transform:scaleY(-1);-ms-transform:scaleY(-1);transform:scaleY(-1)}:root .fa-flip-horizontal,:root .fa-flip-vertical,:root .fa-rotate-90,:root .fa-rotate-180,:root .fa-rotate-270{filter:none}.fa-stack{position:relative;display:inline-block;width:2em;height:2em;line-height:2em;vertical-align:middle}.fa-stack-1x,.fa-stack-2x{position:absolute;left:0;width:100%;text-align:center}.fa-stack-1x{line-height:inherit}.fa-stack-2x{font-size:2em}.fa-inverse{color:#fff}.fa-glass:before{content:""}.fa-music:before{content:""}.fa-search:before,.icon-search:before{content:""}.fa-envelope-o:before{content:""}.fa-heart:before{content:""}.fa-star:before{content:""}.fa-star-o:before{content:""}.fa-user:before{content:""}.fa-film:before{content:""}.fa-th-large:before{content:""}.fa-th:before{content:""}.fa-th-list:before{content:""}.fa-check:before{content:""}.fa-close:before,.fa-remove:before,.fa-times:before{content:""}.fa-search-plus:before{content:""}.fa-search-minus:before{content:""}.fa-power-off:before{content:""}.fa-signal:before{content:""}.fa-cog:before,.fa-gear:before{content:""}.fa-trash-o:before{content:""}.fa-home:before,.icon-home:before{content:""}.fa-file-o:before{content:""}.fa-clock-o:before{content:""}.fa-road:before{content:""}.fa-download:before,.rst-content code.download span:first-child:before,.rst-content tt.download span:first-child:before{content:""}.fa-arrow-circle-o-down:before{content:""}.fa-arrow-circle-o-up:before{content:""}.fa-inbox:before{content:""}.fa-play-circle-o:before{content:""}.fa-repeat:before,.fa-rotate-right:before{content:""}.fa-refresh:before{content:""}.fa-list-alt:before{content:""}.fa-lock:before{content:""}.fa-flag:before{content:""}.fa-headphones:before{content:""}.fa-volume-off:before{content:""}.fa-volume-down:before{content:""}.fa-volume-up:before{content:""}.fa-qrcode:before{content:""}.fa-barcode:before{content:""}.fa-tag:before{content:""}.fa-tags:before{content:""}.fa-book:before,.icon-book:before{content:""}.fa-bookmark:before{content:""}.fa-print:before{content:""}.fa-camera:before{content:""}.fa-font:before{content:""}.fa-bold:before{content:""}.fa-italic:before{content:""}.fa-text-height:before{content:""}.fa-text-width:before{content:""}.fa-align-left:before{content:""}.fa-align-center:before{content:""}.fa-align-right:before{content:""}.fa-align-justify:before{content:""}.fa-list:before{content:""}.fa-dedent:before,.fa-outdent:before{content:""}.fa-indent:before{content:""}.fa-video-camera:before{content:""}.fa-image:before,.fa-photo:before,.fa-picture-o:before{content:""}.fa-pencil:before{content:""}.fa-map-marker:before{content:""}.fa-adjust:before{content:""}.fa-tint:before{content:""}.fa-edit:before,.fa-pencil-square-o:before{content:""}.fa-share-square-o:before{content:""}.fa-check-square-o:before{content:""}.fa-arrows:before{content:""}.fa-step-backward:before{content:""}.fa-fast-backward:before{content:""}.fa-backward:before{content:""}.fa-play:before{content:""}.fa-pause:before{content:""}.fa-stop:before{content:""}.fa-forward:before{content:""}.fa-fast-forward:before{content:""}.fa-step-forward:before{content:""}.fa-eject:before{content:""}.fa-chevron-left:before{content:""}.fa-chevron-right:before{content:""}.fa-plus-circle:before{content:""}.fa-minus-circle:before{content:""}.fa-times-circle:before,.wy-inline-validate.wy-inline-validate-danger .wy-input-context:before{content:""}.fa-check-circle:before,.wy-inline-validate.wy-inline-validate-success .wy-input-context:before{content:""}.fa-question-circle:before{content:""}.fa-info-circle:before{content:""}.fa-crosshairs:before{content:""}.fa-times-circle-o:before{content:""}.fa-check-circle-o:before{content:""}.fa-ban:before{content:""}.fa-arrow-left:before{content:""}.fa-arrow-right:before{content:""}.fa-arrow-up:before{content:""}.fa-arrow-down:before{content:""}.fa-mail-forward:before,.fa-share:before{content:""}.fa-expand:before{content:""}.fa-compress:before{content:""}.fa-plus:before{content:""}.fa-minus:before{content:""}.fa-asterisk:before{content:""}.fa-exclamation-circle:before,.rst-content .admonition-title:before,.wy-inline-validate.wy-inline-validate-info .wy-input-context:before,.wy-inline-validate.wy-inline-validate-warning .wy-input-context:before{content:""}.fa-gift:before{content:""}.fa-leaf:before{content:""}.fa-fire:before,.icon-fire:before{content:""}.fa-eye:before{content:""}.fa-eye-slash:before{content:""}.fa-exclamation-triangle:before,.fa-warning:before{content:""}.fa-plane:before{content:""}.fa-calendar:before{content:""}.fa-random:before{content:""}.fa-comment:before{content:""}.fa-magnet:before{content:""}.fa-chevron-up:before{content:""}.fa-chevron-down:before{content:""}.fa-retweet:before{content:""}.fa-shopping-cart:before{content:""}.fa-folder:before{content:""}.fa-folder-open:before{content:""}.fa-arrows-v:before{content:""}.fa-arrows-h:before{content:""}.fa-bar-chart-o:before,.fa-bar-chart:before{content:""}.fa-twitter-square:before{content:""}.fa-facebook-square:before{content:""}.fa-camera-retro:before{content:""}.fa-key:before{content:""}.fa-cogs:before,.fa-gears:before{content:""}.fa-comments:before{content:""}.fa-thumbs-o-up:before{content:""}.fa-thumbs-o-down:before{content:""}.fa-star-half:before{content:""}.fa-heart-o:before{content:""}.fa-sign-out:before{content:""}.fa-linkedin-square:before{content:""}.fa-thumb-tack:before{content:""}.fa-external-link:before{content:""}.fa-sign-in:before{content:""}.fa-trophy:before{content:""}.fa-github-square:before{content:""}.fa-upload:before{content:""}.fa-lemon-o:before{content:""}.fa-phone:before{content:""}.fa-square-o:before{content:""}.fa-bookmark-o:before{content:""}.fa-phone-square:before{content:""}.fa-twitter:before{content:""}.fa-facebook-f:before,.fa-facebook:before{content:""}.fa-github:before,.icon-github:before{content:""}.fa-unlock:before{content:""}.fa-credit-card:before{content:""}.fa-feed:before,.fa-rss:before{content:""}.fa-hdd-o:before{content:""}.fa-bullhorn:before{content:""}.fa-bell:before{content:""}.fa-certificate:before{content:""}.fa-hand-o-right:before{content:""}.fa-hand-o-left:before{content:""}.fa-hand-o-up:before{content:""}.fa-hand-o-down:before{content:""}.fa-arrow-circle-left:before,.icon-circle-arrow-left:before{content:""}.fa-arrow-circle-right:before,.icon-circle-arrow-right:before{content:""}.fa-arrow-circle-up:before{content:""}.fa-arrow-circle-down:before{content:""}.fa-globe:before{content:""}.fa-wrench:before{content:""}.fa-tasks:before{content:""}.fa-filter:before{content:""}.fa-briefcase:before{content:""}.fa-arrows-alt:before{content:""}.fa-group:before,.fa-users:before{content:""}.fa-chain:before,.fa-link:before,.icon-link:before{content:""}.fa-cloud:before{content:""}.fa-flask:before{content:""}.fa-cut:before,.fa-scissors:before{content:""}.fa-copy:before,.fa-files-o:before{content:""}.fa-paperclip:before{content:""}.fa-floppy-o:before,.fa-save:before{content:""}.fa-square:before{content:""}.fa-bars:before,.fa-navicon:before,.fa-reorder:before{content:""}.fa-list-ul:before{content:""}.fa-list-ol:before{content:""}.fa-strikethrough:before{content:""}.fa-underline:before{content:""}.fa-table:before{content:""}.fa-magic:before{content:""}.fa-truck:before{content:""}.fa-pinterest:before{content:""}.fa-pinterest-square:before{content:""}.fa-google-plus-square:before{content:""}.fa-google-plus:before{content:""}.fa-money:before{content:""}.fa-caret-down:before,.icon-caret-down:before,.wy-dropdown .caret:before{content:""}.fa-caret-up:before{content:""}.fa-caret-left:before{content:""}.fa-caret-right:before{content:""}.fa-columns:before{content:""}.fa-sort:before,.fa-unsorted:before{content:""}.fa-sort-desc:before,.fa-sort-down:before{content:""}.fa-sort-asc:before,.fa-sort-up:before{content:""}.fa-envelope:before{content:""}.fa-linkedin:before{content:""}.fa-rotate-left:before,.fa-undo:before{content:""}.fa-gavel:before,.fa-legal:before{content:""}.fa-dashboard:before,.fa-tachometer:before{content:""}.fa-comment-o:before{content:""}.fa-comments-o:before{content:""}.fa-bolt:before,.fa-flash:before{content:""}.fa-sitemap:before{content:""}.fa-umbrella:before{content:""}.fa-clipboard:before,.fa-paste:before{content:""}.fa-lightbulb-o:before{content:""}.fa-exchange:before{content:""}.fa-cloud-download:before{content:""}.fa-cloud-upload:before{content:""}.fa-user-md:before{content:""}.fa-stethoscope:before{content:""}.fa-suitcase:before{content:""}.fa-bell-o:before{content:""}.fa-coffee:before{content:""}.fa-cutlery:before{content:""}.fa-file-text-o:before{content:""}.fa-building-o:before{content:""}.fa-hospital-o:before{content:""}.fa-ambulance:before{content:""}.fa-medkit:before{content:""}.fa-fighter-jet:before{content:""}.fa-beer:before{content:""}.fa-h-square:before{content:""}.fa-plus-square:before{content:""}.fa-angle-double-left:before{content:""}.fa-angle-double-right:before{content:""}.fa-angle-double-up:before{content:""}.fa-angle-double-down:before{content:""}.fa-angle-left:before{content:""}.fa-angle-right:before{content:""}.fa-angle-up:before{content:""}.fa-angle-down:before{content:""}.fa-desktop:before{content:""}.fa-laptop:before{content:""}.fa-tablet:before{content:""}.fa-mobile-phone:before,.fa-mobile:before{content:""}.fa-circle-o:before{content:""}.fa-quote-left:before{content:""}.fa-quote-right:before{content:""}.fa-spinner:before{content:""}.fa-circle:before{content:""}.fa-mail-reply:before,.fa-reply:before{content:""}.fa-github-alt:before{content:""}.fa-folder-o:before{content:""}.fa-folder-open-o:before{content:""}.fa-smile-o:before{content:""}.fa-frown-o:before{content:""}.fa-meh-o:before{content:""}.fa-gamepad:before{content:""}.fa-keyboard-o:before{content:""}.fa-flag-o:before{content:""}.fa-flag-checkered:before{content:""}.fa-terminal:before{content:""}.fa-code:before{content:""}.fa-mail-reply-all:before,.fa-reply-all:before{content:""}.fa-star-half-empty:before,.fa-star-half-full:before,.fa-star-half-o:before{content:""}.fa-location-arrow:before{content:""}.fa-crop:before{content:""}.fa-code-fork:before{content:""}.fa-chain-broken:before,.fa-unlink:before{content:""}.fa-question:before{content:""}.fa-info:before{content:""}.fa-exclamation:before{content:""}.fa-superscript:before{content:""}.fa-subscript:before{content:""}.fa-eraser:before{content:""}.fa-puzzle-piece:before{content:""}.fa-microphone:before{content:""}.fa-microphone-slash:before{content:""}.fa-shield:before{content:""}.fa-calendar-o:before{content:""}.fa-fire-extinguisher:before{content:""}.fa-rocket:before{content:""}.fa-maxcdn:before{content:""}.fa-chevron-circle-left:before{content:""}.fa-chevron-circle-right:before{content:""}.fa-chevron-circle-up:before{content:""}.fa-chevron-circle-down:before{content:""}.fa-html5:before{content:""}.fa-css3:before{content:""}.fa-anchor:before{content:""}.fa-unlock-alt:before{content:""}.fa-bullseye:before{content:""}.fa-ellipsis-h:before{content:""}.fa-ellipsis-v:before{content:""}.fa-rss-square:before{content:""}.fa-play-circle:before{content:""}.fa-ticket:before{content:""}.fa-minus-square:before{content:""}.fa-minus-square-o:before,.wy-menu-vertical li.current>a button.toctree-expand:before,.wy-menu-vertical li.on a button.toctree-expand:before{content:""}.fa-level-up:before{content:""}.fa-level-down:before{content:""}.fa-check-square:before{content:""}.fa-pencil-square:before{content:""}.fa-external-link-square:before{content:""}.fa-share-square:before{content:""}.fa-compass:before{content:""}.fa-caret-square-o-down:before,.fa-toggle-down:before{content:""}.fa-caret-square-o-up:before,.fa-toggle-up:before{content:""}.fa-caret-square-o-right:before,.fa-toggle-right:before{content:""}.fa-eur:before,.fa-euro:before{content:""}.fa-gbp:before{content:""}.fa-dollar:before,.fa-usd:before{content:""}.fa-inr:before,.fa-rupee:before{content:""}.fa-cny:before,.fa-jpy:before,.fa-rmb:before,.fa-yen:before{content:""}.fa-rouble:before,.fa-rub:before,.fa-ruble:before{content:""}.fa-krw:before,.fa-won:before{content:""}.fa-bitcoin:before,.fa-btc:before{content:""}.fa-file:before{content:""}.fa-file-text:before{content:""}.fa-sort-alpha-asc:before{content:""}.fa-sort-alpha-desc:before{content:""}.fa-sort-amount-asc:before{content:""}.fa-sort-amount-desc:before{content:""}.fa-sort-numeric-asc:before{content:""}.fa-sort-numeric-desc:before{content:""}.fa-thumbs-up:before{content:""}.fa-thumbs-down:before{content:""}.fa-youtube-square:before{content:""}.fa-youtube:before{content:""}.fa-xing:before{content:""}.fa-xing-square:before{content:""}.fa-youtube-play:before{content:""}.fa-dropbox:before{content:""}.fa-stack-overflow:before{content:""}.fa-instagram:before{content:""}.fa-flickr:before{content:""}.fa-adn:before{content:""}.fa-bitbucket:before,.icon-bitbucket:before{content:""}.fa-bitbucket-square:before{content:""}.fa-tumblr:before{content:""}.fa-tumblr-square:before{content:""}.fa-long-arrow-down:before{content:""}.fa-long-arrow-up:before{content:""}.fa-long-arrow-left:before{content:""}.fa-long-arrow-right:before{content:""}.fa-apple:before{content:""}.fa-windows:before{content:""}.fa-android:before{content:""}.fa-linux:before{content:""}.fa-dribbble:before{content:""}.fa-skype:before{content:""}.fa-foursquare:before{content:""}.fa-trello:before{content:""}.fa-female:before{content:""}.fa-male:before{content:""}.fa-gittip:before,.fa-gratipay:before{content:""}.fa-sun-o:before{content:""}.fa-moon-o:before{content:""}.fa-archive:before{content:""}.fa-bug:before{content:""}.fa-vk:before{content:""}.fa-weibo:before{content:""}.fa-renren:before{content:""}.fa-pagelines:before{content:""}.fa-stack-exchange:before{content:""}.fa-arrow-circle-o-right:before{content:""}.fa-arrow-circle-o-left:before{content:""}.fa-caret-square-o-left:before,.fa-toggle-left:before{content:""}.fa-dot-circle-o:before{content:""}.fa-wheelchair:before{content:""}.fa-vimeo-square:before{content:""}.fa-try:before,.fa-turkish-lira:before{content:""}.fa-plus-square-o:before,.wy-menu-vertical li button.toctree-expand:before{content:""}.fa-space-shuttle:before{content:""}.fa-slack:before{content:""}.fa-envelope-square:before{content:""}.fa-wordpress:before{content:""}.fa-openid:before{content:""}.fa-bank:before,.fa-institution:before,.fa-university:before{content:""}.fa-graduation-cap:before,.fa-mortar-board:before{content:""}.fa-yahoo:before{content:""}.fa-google:before{content:""}.fa-reddit:before{content:""}.fa-reddit-square:before{content:""}.fa-stumbleupon-circle:before{content:""}.fa-stumbleupon:before{content:""}.fa-delicious:before{content:""}.fa-digg:before{content:""}.fa-pied-piper-pp:before{content:""}.fa-pied-piper-alt:before{content:""}.fa-drupal:before{content:""}.fa-joomla:before{content:""}.fa-language:before{content:""}.fa-fax:before{content:""}.fa-building:before{content:""}.fa-child:before{content:""}.fa-paw:before{content:""}.fa-spoon:before{content:""}.fa-cube:before{content:""}.fa-cubes:before{content:""}.fa-behance:before{content:""}.fa-behance-square:before{content:""}.fa-steam:before{content:""}.fa-steam-square:before{content:""}.fa-recycle:before{content:""}.fa-automobile:before,.fa-car:before{content:""}.fa-cab:before,.fa-taxi:before{content:""}.fa-tree:before{content:""}.fa-spotify:before{content:""}.fa-deviantart:before{content:""}.fa-soundcloud:before{content:""}.fa-database:before{content:""}.fa-file-pdf-o:before{content:""}.fa-file-word-o:before{content:""}.fa-file-excel-o:before{content:""}.fa-file-powerpoint-o:before{content:""}.fa-file-image-o:before,.fa-file-photo-o:before,.fa-file-picture-o:before{content:""}.fa-file-archive-o:before,.fa-file-zip-o:before{content:""}.fa-file-audio-o:before,.fa-file-sound-o:before{content:""}.fa-file-movie-o:before,.fa-file-video-o:before{content:""}.fa-file-code-o:before{content:""}.fa-vine:before{content:""}.fa-codepen:before{content:""}.fa-jsfiddle:before{content:""}.fa-life-bouy:before,.fa-life-buoy:before,.fa-life-ring:before,.fa-life-saver:before,.fa-support:before{content:""}.fa-circle-o-notch:before{content:""}.fa-ra:before,.fa-rebel:before,.fa-resistance:before{content:""}.fa-empire:before,.fa-ge:before{content:""}.fa-git-square:before{content:""}.fa-git:before{content:""}.fa-hacker-news:before,.fa-y-combinator-square:before,.fa-yc-square:before{content:""}.fa-tencent-weibo:before{content:""}.fa-qq:before{content:""}.fa-wechat:before,.fa-weixin:before{content:""}.fa-paper-plane:before,.fa-send:before{content:""}.fa-paper-plane-o:before,.fa-send-o:before{content:""}.fa-history:before{content:""}.fa-circle-thin:before{content:""}.fa-header:before{content:""}.fa-paragraph:before{content:""}.fa-sliders:before{content:""}.fa-share-alt:before{content:""}.fa-share-alt-square:before{content:""}.fa-bomb:before{content:""}.fa-futbol-o:before,.fa-soccer-ball-o:before{content:""}.fa-tty:before{content:""}.fa-binoculars:before{content:""}.fa-plug:before{content:""}.fa-slideshare:before{content:""}.fa-twitch:before{content:""}.fa-yelp:before{content:""}.fa-newspaper-o:before{content:""}.fa-wifi:before{content:""}.fa-calculator:before{content:""}.fa-paypal:before{content:""}.fa-google-wallet:before{content:""}.fa-cc-visa:before{content:""}.fa-cc-mastercard:before{content:""}.fa-cc-discover:before{content:""}.fa-cc-amex:before{content:""}.fa-cc-paypal:before{content:""}.fa-cc-stripe:before{content:""}.fa-bell-slash:before{content:""}.fa-bell-slash-o:before{content:""}.fa-trash:before{content:""}.fa-copyright:before{content:""}.fa-at:before{content:""}.fa-eyedropper:before{content:""}.fa-paint-brush:before{content:""}.fa-birthday-cake:before{content:""}.fa-area-chart:before{content:""}.fa-pie-chart:before{content:""}.fa-line-chart:before{content:""}.fa-lastfm:before{content:""}.fa-lastfm-square:before{content:""}.fa-toggle-off:before{content:""}.fa-toggle-on:before{content:""}.fa-bicycle:before{content:""}.fa-bus:before{content:""}.fa-ioxhost:before{content:""}.fa-angellist:before{content:""}.fa-cc:before{content:""}.fa-ils:before,.fa-shekel:before,.fa-sheqel:before{content:""}.fa-meanpath:before{content:""}.fa-buysellads:before{content:""}.fa-connectdevelop:before{content:""}.fa-dashcube:before{content:""}.fa-forumbee:before{content:""}.fa-leanpub:before{content:""}.fa-sellsy:before{content:""}.fa-shirtsinbulk:before{content:""}.fa-simplybuilt:before{content:""}.fa-skyatlas:before{content:""}.fa-cart-plus:before{content:""}.fa-cart-arrow-down:before{content:""}.fa-diamond:before{content:""}.fa-ship:before{content:""}.fa-user-secret:before{content:""}.fa-motorcycle:before{content:""}.fa-street-view:before{content:""}.fa-heartbeat:before{content:""}.fa-venus:before{content:""}.fa-mars:before{content:""}.fa-mercury:before{content:""}.fa-intersex:before,.fa-transgender:before{content:""}.fa-transgender-alt:before{content:""}.fa-venus-double:before{content:""}.fa-mars-double:before{content:""}.fa-venus-mars:before{content:""}.fa-mars-stroke:before{content:""}.fa-mars-stroke-v:before{content:""}.fa-mars-stroke-h:before{content:""}.fa-neuter:before{content:""}.fa-genderless:before{content:""}.fa-facebook-official:before{content:""}.fa-pinterest-p:before{content:""}.fa-whatsapp:before{content:""}.fa-server:before{content:""}.fa-user-plus:before{content:""}.fa-user-times:before{content:""}.fa-bed:before,.fa-hotel:before{content:""}.fa-viacoin:before{content:""}.fa-train:before{content:""}.fa-subway:before{content:""}.fa-medium:before{content:""}.fa-y-combinator:before,.fa-yc:before{content:""}.fa-optin-monster:before{content:""}.fa-opencart:before{content:""}.fa-expeditedssl:before{content:""}.fa-battery-4:before,.fa-battery-full:before,.fa-battery:before{content:""}.fa-battery-3:before,.fa-battery-three-quarters:before{content:""}.fa-battery-2:before,.fa-battery-half:before{content:""}.fa-battery-1:before,.fa-battery-quarter:before{content:""}.fa-battery-0:before,.fa-battery-empty:before{content:""}.fa-mouse-pointer:before{content:""}.fa-i-cursor:before{content:""}.fa-object-group:before{content:""}.fa-object-ungroup:before{content:""}.fa-sticky-note:before{content:""}.fa-sticky-note-o:before{content:""}.fa-cc-jcb:before{content:""}.fa-cc-diners-club:before{content:""}.fa-clone:before{content:""}.fa-balance-scale:before{content:""}.fa-hourglass-o:before{content:""}.fa-hourglass-1:before,.fa-hourglass-start:before{content:""}.fa-hourglass-2:before,.fa-hourglass-half:before{content:""}.fa-hourglass-3:before,.fa-hourglass-end:before{content:""}.fa-hourglass:before{content:""}.fa-hand-grab-o:before,.fa-hand-rock-o:before{content:""}.fa-hand-paper-o:before,.fa-hand-stop-o:before{content:""}.fa-hand-scissors-o:before{content:""}.fa-hand-lizard-o:before{content:""}.fa-hand-spock-o:before{content:""}.fa-hand-pointer-o:before{content:""}.fa-hand-peace-o:before{content:""}.fa-trademark:before{content:""}.fa-registered:before{content:""}.fa-creative-commons:before{content:""}.fa-gg:before{content:""}.fa-gg-circle:before{content:""}.fa-tripadvisor:before{content:""}.fa-odnoklassniki:before{content:""}.fa-odnoklassniki-square:before{content:""}.fa-get-pocket:before{content:""}.fa-wikipedia-w:before{content:""}.fa-safari:before{content:""}.fa-chrome:before{content:""}.fa-firefox:before{content:""}.fa-opera:before{content:""}.fa-internet-explorer:before{content:""}.fa-television:before,.fa-tv:before{content:""}.fa-contao:before{content:""}.fa-500px:before{content:""}.fa-amazon:before{content:""}.fa-calendar-plus-o:before{content:""}.fa-calendar-minus-o:before{content:""}.fa-calendar-times-o:before{content:""}.fa-calendar-check-o:before{content:""}.fa-industry:before{content:""}.fa-map-pin:before{content:""}.fa-map-signs:before{content:""}.fa-map-o:before{content:""}.fa-map:before{content:""}.fa-commenting:before{content:""}.fa-commenting-o:before{content:""}.fa-houzz:before{content:""}.fa-vimeo:before{content:""}.fa-black-tie:before{content:""}.fa-fonticons:before{content:""}.fa-reddit-alien:before{content:""}.fa-edge:before{content:""}.fa-credit-card-alt:before{content:""}.fa-codiepie:before{content:""}.fa-modx:before{content:""}.fa-fort-awesome:before{content:""}.fa-usb:before{content:""}.fa-product-hunt:before{content:""}.fa-mixcloud:before{content:""}.fa-scribd:before{content:""}.fa-pause-circle:before{content:""}.fa-pause-circle-o:before{content:""}.fa-stop-circle:before{content:""}.fa-stop-circle-o:before{content:""}.fa-shopping-bag:before{content:""}.fa-shopping-basket:before{content:""}.fa-hashtag:before{content:""}.fa-bluetooth:before{content:""}.fa-bluetooth-b:before{content:""}.fa-percent:before{content:""}.fa-gitlab:before,.icon-gitlab:before{content:""}.fa-wpbeginner:before{content:""}.fa-wpforms:before{content:""}.fa-envira:before{content:""}.fa-universal-access:before{content:""}.fa-wheelchair-alt:before{content:""}.fa-question-circle-o:before{content:""}.fa-blind:before{content:""}.fa-audio-description:before{content:""}.fa-volume-control-phone:before{content:""}.fa-braille:before{content:""}.fa-assistive-listening-systems:before{content:""}.fa-american-sign-language-interpreting:before,.fa-asl-interpreting:before{content:""}.fa-deaf:before,.fa-deafness:before,.fa-hard-of-hearing:before{content:""}.fa-glide:before{content:""}.fa-glide-g:before{content:""}.fa-sign-language:before,.fa-signing:before{content:""}.fa-low-vision:before{content:""}.fa-viadeo:before{content:""}.fa-viadeo-square:before{content:""}.fa-snapchat:before{content:""}.fa-snapchat-ghost:before{content:""}.fa-snapchat-square:before{content:""}.fa-pied-piper:before{content:""}.fa-first-order:before{content:""}.fa-yoast:before{content:""}.fa-themeisle:before{content:""}.fa-google-plus-circle:before,.fa-google-plus-official:before{content:""}.fa-fa:before,.fa-font-awesome:before{content:""}.fa-handshake-o:before{content:""}.fa-envelope-open:before{content:""}.fa-envelope-open-o:before{content:""}.fa-linode:before{content:""}.fa-address-book:before{content:""}.fa-address-book-o:before{content:""}.fa-address-card:before,.fa-vcard:before{content:""}.fa-address-card-o:before,.fa-vcard-o:before{content:""}.fa-user-circle:before{content:""}.fa-user-circle-o:before{content:""}.fa-user-o:before{content:""}.fa-id-badge:before{content:""}.fa-drivers-license:before,.fa-id-card:before{content:""}.fa-drivers-license-o:before,.fa-id-card-o:before{content:""}.fa-quora:before{content:""}.fa-free-code-camp:before{content:""}.fa-telegram:before{content:""}.fa-thermometer-4:before,.fa-thermometer-full:before,.fa-thermometer:before{content:""}.fa-thermometer-3:before,.fa-thermometer-three-quarters:before{content:""}.fa-thermometer-2:before,.fa-thermometer-half:before{content:""}.fa-thermometer-1:before,.fa-thermometer-quarter:before{content:""}.fa-thermometer-0:before,.fa-thermometer-empty:before{content:""}.fa-shower:before{content:""}.fa-bath:before,.fa-bathtub:before,.fa-s15:before{content:""}.fa-podcast:before{content:""}.fa-window-maximize:before{content:""}.fa-window-minimize:before{content:""}.fa-window-restore:before{content:""}.fa-times-rectangle:before,.fa-window-close:before{content:""}.fa-times-rectangle-o:before,.fa-window-close-o:before{content:""}.fa-bandcamp:before{content:""}.fa-grav:before{content:""}.fa-etsy:before{content:""}.fa-imdb:before{content:""}.fa-ravelry:before{content:""}.fa-eercast:before{content:""}.fa-microchip:before{content:""}.fa-snowflake-o:before{content:""}.fa-superpowers:before{content:""}.fa-wpexplorer:before{content:""}.fa-meetup:before{content:""}.sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);border:0}.sr-only-focusable:active,.sr-only-focusable:focus{position:static;width:auto;height:auto;margin:0;overflow:visible;clip:auto}.fa,.icon,.rst-content .admonition-title,.rst-content .code-block-caption .headerlink,.rst-content .eqno .headerlink,.rst-content code.download span:first-child,.rst-content dl dt .headerlink,.rst-content h1 .headerlink,.rst-content h2 .headerlink,.rst-content h3 .headerlink,.rst-content h4 .headerlink,.rst-content h5 .headerlink,.rst-content h6 .headerlink,.rst-content p.caption .headerlink,.rst-content p .headerlink,.rst-content table>caption .headerlink,.rst-content tt.download span:first-child,.wy-dropdown .caret,.wy-inline-validate.wy-inline-validate-danger .wy-input-context,.wy-inline-validate.wy-inline-validate-info .wy-input-context,.wy-inline-validate.wy-inline-validate-success .wy-input-context,.wy-inline-validate.wy-inline-validate-warning .wy-input-context,.wy-menu-vertical li.current>a button.toctree-expand,.wy-menu-vertical li.on a button.toctree-expand,.wy-menu-vertical li button.toctree-expand{font-family:inherit}.fa:before,.icon:before,.rst-content .admonition-title:before,.rst-content .code-block-caption .headerlink:before,.rst-content .eqno .headerlink:before,.rst-content code.download span:first-child:before,.rst-content dl dt .headerlink:before,.rst-content h1 .headerlink:before,.rst-content h2 .headerlink:before,.rst-content h3 .headerlink:before,.rst-content h4 .headerlink:before,.rst-content h5 .headerlink:before,.rst-content h6 .headerlink:before,.rst-content p.caption .headerlink:before,.rst-content p .headerlink:before,.rst-content table>caption .headerlink:before,.rst-content tt.download span:first-child:before,.wy-dropdown .caret:before,.wy-inline-validate.wy-inline-validate-danger .wy-input-context:before,.wy-inline-validate.wy-inline-validate-info .wy-input-context:before,.wy-inline-validate.wy-inline-validate-success .wy-input-context:before,.wy-inline-validate.wy-inline-validate-warning .wy-input-context:before,.wy-menu-vertical li.current>a button.toctree-expand:before,.wy-menu-vertical li.on a button.toctree-expand:before,.wy-menu-vertical li button.toctree-expand:before{font-family:FontAwesome;display:inline-block;font-style:normal;font-weight:400;line-height:1;text-decoration:inherit}.rst-content .code-block-caption a .headerlink,.rst-content .eqno a .headerlink,.rst-content a .admonition-title,.rst-content code.download a span:first-child,.rst-content dl dt a .headerlink,.rst-content h1 a .headerlink,.rst-content h2 a .headerlink,.rst-content h3 a .headerlink,.rst-content h4 a .headerlink,.rst-content h5 a .headerlink,.rst-content h6 a .headerlink,.rst-content p.caption a .headerlink,.rst-content p a .headerlink,.rst-content table>caption a .headerlink,.rst-content tt.download a span:first-child,.wy-menu-vertical li.current>a button.toctree-expand,.wy-menu-vertical li.on a button.toctree-expand,.wy-menu-vertical li a button.toctree-expand,a .fa,a .icon,a .rst-content .admonition-title,a .rst-content .code-block-caption .headerlink,a .rst-content .eqno .headerlink,a .rst-content code.download span:first-child,a .rst-content dl dt .headerlink,a .rst-content h1 .headerlink,a .rst-content h2 .headerlink,a .rst-content h3 .headerlink,a .rst-content h4 .headerlink,a .rst-content h5 .headerlink,a .rst-content h6 .headerlink,a .rst-content p.caption .headerlink,a .rst-content p .headerlink,a .rst-content table>caption .headerlink,a .rst-content tt.download span:first-child,a .wy-menu-vertical li button.toctree-expand{display:inline-block;text-decoration:inherit}.btn .fa,.btn .icon,.btn .rst-content .admonition-title,.btn .rst-content .code-block-caption .headerlink,.btn .rst-content .eqno .headerlink,.btn .rst-content code.download span:first-child,.btn .rst-content dl dt .headerlink,.btn .rst-content h1 .headerlink,.btn .rst-content h2 .headerlink,.btn .rst-content h3 .headerlink,.btn .rst-content h4 .headerlink,.btn .rst-content h5 .headerlink,.btn .rst-content h6 .headerlink,.btn .rst-content p .headerlink,.btn .rst-content table>caption .headerlink,.btn .rst-content tt.download span:first-child,.btn .wy-menu-vertical li.current>a button.toctree-expand,.btn .wy-menu-vertical li.on a button.toctree-expand,.btn .wy-menu-vertical li button.toctree-expand,.nav .fa,.nav .icon,.nav .rst-content .admonition-title,.nav .rst-content .code-block-caption .headerlink,.nav .rst-content .eqno .headerlink,.nav .rst-content code.download span:first-child,.nav .rst-content dl dt .headerlink,.nav .rst-content h1 .headerlink,.nav .rst-content h2 .headerlink,.nav .rst-content h3 .headerlink,.nav .rst-content h4 .headerlink,.nav .rst-content h5 .headerlink,.nav .rst-content h6 .headerlink,.nav .rst-content p .headerlink,.nav .rst-content table>caption .headerlink,.nav .rst-content tt.download span:first-child,.nav .wy-menu-vertical li.current>a button.toctree-expand,.nav .wy-menu-vertical li.on a button.toctree-expand,.nav .wy-menu-vertical li button.toctree-expand,.rst-content .btn .admonition-title,.rst-content .code-block-caption .btn .headerlink,.rst-content .code-block-caption .nav .headerlink,.rst-content .eqno .btn .headerlink,.rst-content .eqno .nav .headerlink,.rst-content .nav .admonition-title,.rst-content code.download .btn span:first-child,.rst-content code.download .nav span:first-child,.rst-content dl dt .btn .headerlink,.rst-content dl dt .nav .headerlink,.rst-content h1 .btn .headerlink,.rst-content h1 .nav .headerlink,.rst-content h2 .btn .headerlink,.rst-content h2 .nav .headerlink,.rst-content h3 .btn .headerlink,.rst-content h3 .nav .headerlink,.rst-content h4 .btn .headerlink,.rst-content h4 .nav .headerlink,.rst-content h5 .btn .headerlink,.rst-content h5 .nav .headerlink,.rst-content h6 .btn .headerlink,.rst-content h6 .nav .headerlink,.rst-content p .btn .headerlink,.rst-content p .nav .headerlink,.rst-content table>caption .btn .headerlink,.rst-content table>caption .nav .headerlink,.rst-content tt.download .btn span:first-child,.rst-content tt.download .nav span:first-child,.wy-menu-vertical li .btn button.toctree-expand,.wy-menu-vertical li.current>a .btn button.toctree-expand,.wy-menu-vertical li.current>a .nav button.toctree-expand,.wy-menu-vertical li .nav button.toctree-expand,.wy-menu-vertical li.on a .btn button.toctree-expand,.wy-menu-vertical li.on a .nav button.toctree-expand{display:inline}.btn .fa-large.icon,.btn .fa.fa-large,.btn .rst-content .code-block-caption .fa-large.headerlink,.btn .rst-content .eqno .fa-large.headerlink,.btn .rst-content .fa-large.admonition-title,.btn .rst-content code.download span.fa-large:first-child,.btn .rst-content dl dt .fa-large.headerlink,.btn .rst-content h1 .fa-large.headerlink,.btn .rst-content h2 .fa-large.headerlink,.btn .rst-content h3 .fa-large.headerlink,.btn .rst-content h4 .fa-large.headerlink,.btn .rst-content h5 .fa-large.headerlink,.btn .rst-content h6 .fa-large.headerlink,.btn .rst-content p .fa-large.headerlink,.btn .rst-content table>caption .fa-large.headerlink,.btn .rst-content tt.download span.fa-large:first-child,.btn .wy-menu-vertical li button.fa-large.toctree-expand,.nav .fa-large.icon,.nav .fa.fa-large,.nav .rst-content .code-block-caption .fa-large.headerlink,.nav .rst-content .eqno .fa-large.headerlink,.nav .rst-content .fa-large.admonition-title,.nav .rst-content code.download span.fa-large:first-child,.nav .rst-content dl dt .fa-large.headerlink,.nav .rst-content h1 .fa-large.headerlink,.nav .rst-content h2 .fa-large.headerlink,.nav .rst-content h3 .fa-large.headerlink,.nav .rst-content h4 .fa-large.headerlink,.nav .rst-content h5 .fa-large.headerlink,.nav .rst-content h6 .fa-large.headerlink,.nav .rst-content p .fa-large.headerlink,.nav .rst-content table>caption .fa-large.headerlink,.nav .rst-content tt.download span.fa-large:first-child,.nav .wy-menu-vertical li button.fa-large.toctree-expand,.rst-content .btn .fa-large.admonition-title,.rst-content .code-block-caption .btn .fa-large.headerlink,.rst-content .code-block-caption .nav .fa-large.headerlink,.rst-content .eqno .btn .fa-large.headerlink,.rst-content .eqno .nav .fa-large.headerlink,.rst-content .nav .fa-large.admonition-title,.rst-content code.download .btn span.fa-large:first-child,.rst-content code.download .nav span.fa-large:first-child,.rst-content dl dt .btn .fa-large.headerlink,.rst-content dl dt .nav .fa-large.headerlink,.rst-content h1 .btn .fa-large.headerlink,.rst-content h1 .nav .fa-large.headerlink,.rst-content h2 .btn .fa-large.headerlink,.rst-content h2 .nav .fa-large.headerlink,.rst-content h3 .btn .fa-large.headerlink,.rst-content h3 .nav .fa-large.headerlink,.rst-content h4 .btn .fa-large.headerlink,.rst-content h4 .nav .fa-large.headerlink,.rst-content h5 .btn .fa-large.headerlink,.rst-content h5 .nav .fa-large.headerlink,.rst-content h6 .btn .fa-large.headerlink,.rst-content h6 .nav .fa-large.headerlink,.rst-content p .btn .fa-large.headerlink,.rst-content p .nav .fa-large.headerlink,.rst-content table>caption .btn .fa-large.headerlink,.rst-content table>caption .nav .fa-large.headerlink,.rst-content tt.download .btn span.fa-large:first-child,.rst-content tt.download .nav span.fa-large:first-child,.wy-menu-vertical li .btn button.fa-large.toctree-expand,.wy-menu-vertical li .nav button.fa-large.toctree-expand{line-height:.9em}.btn .fa-spin.icon,.btn .fa.fa-spin,.btn .rst-content .code-block-caption .fa-spin.headerlink,.btn .rst-content .eqno .fa-spin.headerlink,.btn .rst-content .fa-spin.admonition-title,.btn .rst-content code.download span.fa-spin:first-child,.btn .rst-content dl dt .fa-spin.headerlink,.btn .rst-content h1 .fa-spin.headerlink,.btn .rst-content h2 .fa-spin.headerlink,.btn .rst-content h3 .fa-spin.headerlink,.btn .rst-content h4 .fa-spin.headerlink,.btn .rst-content h5 .fa-spin.headerlink,.btn .rst-content h6 .fa-spin.headerlink,.btn .rst-content p .fa-spin.headerlink,.btn .rst-content table>caption .fa-spin.headerlink,.btn .rst-content tt.download span.fa-spin:first-child,.btn .wy-menu-vertical li button.fa-spin.toctree-expand,.nav .fa-spin.icon,.nav .fa.fa-spin,.nav .rst-content .code-block-caption .fa-spin.headerlink,.nav .rst-content .eqno .fa-spin.headerlink,.nav .rst-content .fa-spin.admonition-title,.nav .rst-content code.download span.fa-spin:first-child,.nav .rst-content dl dt .fa-spin.headerlink,.nav .rst-content h1 .fa-spin.headerlink,.nav .rst-content h2 .fa-spin.headerlink,.nav .rst-content h3 .fa-spin.headerlink,.nav .rst-content h4 .fa-spin.headerlink,.nav .rst-content h5 .fa-spin.headerlink,.nav .rst-content h6 .fa-spin.headerlink,.nav .rst-content p .fa-spin.headerlink,.nav .rst-content table>caption .fa-spin.headerlink,.nav .rst-content tt.download span.fa-spin:first-child,.nav .wy-menu-vertical li button.fa-spin.toctree-expand,.rst-content .btn .fa-spin.admonition-title,.rst-content .code-block-caption .btn .fa-spin.headerlink,.rst-content .code-block-caption .nav .fa-spin.headerlink,.rst-content .eqno .btn .fa-spin.headerlink,.rst-content .eqno .nav .fa-spin.headerlink,.rst-content .nav .fa-spin.admonition-title,.rst-content code.download .btn span.fa-spin:first-child,.rst-content code.download .nav span.fa-spin:first-child,.rst-content dl dt .btn .fa-spin.headerlink,.rst-content dl dt .nav .fa-spin.headerlink,.rst-content h1 .btn .fa-spin.headerlink,.rst-content h1 .nav .fa-spin.headerlink,.rst-content h2 .btn .fa-spin.headerlink,.rst-content h2 .nav .fa-spin.headerlink,.rst-content h3 .btn .fa-spin.headerlink,.rst-content h3 .nav .fa-spin.headerlink,.rst-content h4 .btn .fa-spin.headerlink,.rst-content h4 .nav .fa-spin.headerlink,.rst-content h5 .btn .fa-spin.headerlink,.rst-content h5 .nav .fa-spin.headerlink,.rst-content h6 .btn .fa-spin.headerlink,.rst-content h6 .nav .fa-spin.headerlink,.rst-content p .btn .fa-spin.headerlink,.rst-content p .nav .fa-spin.headerlink,.rst-content table>caption .btn .fa-spin.headerlink,.rst-content table>caption .nav .fa-spin.headerlink,.rst-content tt.download .btn span.fa-spin:first-child,.rst-content tt.download .nav span.fa-spin:first-child,.wy-menu-vertical li .btn button.fa-spin.toctree-expand,.wy-menu-vertical li .nav button.fa-spin.toctree-expand{display:inline-block}.btn.fa:before,.btn.icon:before,.rst-content .btn.admonition-title:before,.rst-content .code-block-caption .btn.headerlink:before,.rst-content .eqno .btn.headerlink:before,.rst-content code.download span.btn:first-child:before,.rst-content dl dt .btn.headerlink:before,.rst-content h1 .btn.headerlink:before,.rst-content h2 .btn.headerlink:before,.rst-content h3 .btn.headerlink:before,.rst-content h4 .btn.headerlink:before,.rst-content h5 .btn.headerlink:before,.rst-content h6 .btn.headerlink:before,.rst-content p .btn.headerlink:before,.rst-content table>caption .btn.headerlink:before,.rst-content tt.download span.btn:first-child:before,.wy-menu-vertical li button.btn.toctree-expand:before{opacity:.5;-webkit-transition:opacity .05s ease-in;-moz-transition:opacity .05s ease-in;transition:opacity .05s ease-in}.btn.fa:hover:before,.btn.icon:hover:before,.rst-content .btn.admonition-title:hover:before,.rst-content .code-block-caption .btn.headerlink:hover:before,.rst-content .eqno .btn.headerlink:hover:before,.rst-content code.download span.btn:first-child:hover:before,.rst-content dl dt .btn.headerlink:hover:before,.rst-content h1 .btn.headerlink:hover:before,.rst-content h2 .btn.headerlink:hover:before,.rst-content h3 .btn.headerlink:hover:before,.rst-content h4 .btn.headerlink:hover:before,.rst-content h5 .btn.headerlink:hover:before,.rst-content h6 .btn.headerlink:hover:before,.rst-content p .btn.headerlink:hover:before,.rst-content table>caption .btn.headerlink:hover:before,.rst-content tt.download span.btn:first-child:hover:before,.wy-menu-vertical li button.btn.toctree-expand:hover:before{opacity:1}.btn-mini .fa:before,.btn-mini .icon:before,.btn-mini .rst-content .admonition-title:before,.btn-mini .rst-content .code-block-caption .headerlink:before,.btn-mini .rst-content .eqno .headerlink:before,.btn-mini .rst-content code.download span:first-child:before,.btn-mini .rst-content dl dt .headerlink:before,.btn-mini .rst-content h1 .headerlink:before,.btn-mini .rst-content h2 .headerlink:before,.btn-mini .rst-content h3 .headerlink:before,.btn-mini .rst-content h4 .headerlink:before,.btn-mini .rst-content h5 .headerlink:before,.btn-mini .rst-content h6 .headerlink:before,.btn-mini .rst-content p .headerlink:before,.btn-mini .rst-content table>caption .headerlink:before,.btn-mini .rst-content tt.download span:first-child:before,.btn-mini .wy-menu-vertical li button.toctree-expand:before,.rst-content .btn-mini .admonition-title:before,.rst-content .code-block-caption .btn-mini .headerlink:before,.rst-content .eqno .btn-mini .headerlink:before,.rst-content code.download .btn-mini span:first-child:before,.rst-content dl dt .btn-mini .headerlink:before,.rst-content h1 .btn-mini .headerlink:before,.rst-content h2 .btn-mini .headerlink:before,.rst-content h3 .btn-mini .headerlink:before,.rst-content h4 .btn-mini .headerlink:before,.rst-content h5 .btn-mini .headerlink:before,.rst-content h6 .btn-mini .headerlink:before,.rst-content p .btn-mini .headerlink:before,.rst-content table>caption .btn-mini .headerlink:before,.rst-content tt.download .btn-mini span:first-child:before,.wy-menu-vertical li .btn-mini button.toctree-expand:before{font-size:14px;vertical-align:-15%}.rst-content .admonition,.rst-content .admonition-todo,.rst-content .attention,.rst-content .caution,.rst-content .danger,.rst-content .error,.rst-content .hint,.rst-content .important,.rst-content .note,.rst-content .seealso,.rst-content .tip,.rst-content .warning,.wy-alert{padding:12px;line-height:24px;margin-bottom:24px;background:#e7f2fa}.rst-content .admonition-title,.wy-alert-title{font-weight:700;display:block;color:#fff;background:#6ab0de;padding:6px 12px;margin:-12px -12px 12px}.rst-content .danger,.rst-content .error,.rst-content .wy-alert-danger.admonition,.rst-content .wy-alert-danger.admonition-todo,.rst-content .wy-alert-danger.attention,.rst-content .wy-alert-danger.caution,.rst-content .wy-alert-danger.hint,.rst-content .wy-alert-danger.important,.rst-content .wy-alert-danger.note,.rst-content .wy-alert-danger.seealso,.rst-content .wy-alert-danger.tip,.rst-content .wy-alert-danger.warning,.wy-alert.wy-alert-danger{background:#fdf3f2}.rst-content .danger .admonition-title,.rst-content .danger .wy-alert-title,.rst-content .error .admonition-title,.rst-content .error .wy-alert-title,.rst-content .wy-alert-danger.admonition-todo .admonition-title,.rst-content .wy-alert-danger.admonition-todo .wy-alert-title,.rst-content .wy-alert-danger.admonition .admonition-title,.rst-content .wy-alert-danger.admonition .wy-alert-title,.rst-content .wy-alert-danger.attention .admonition-title,.rst-content .wy-alert-danger.attention .wy-alert-title,.rst-content .wy-alert-danger.caution .admonition-title,.rst-content .wy-alert-danger.caution .wy-alert-title,.rst-content .wy-alert-danger.hint .admonition-title,.rst-content .wy-alert-danger.hint .wy-alert-title,.rst-content .wy-alert-danger.important .admonition-title,.rst-content .wy-alert-danger.important .wy-alert-title,.rst-content .wy-alert-danger.note .admonition-title,.rst-content .wy-alert-danger.note .wy-alert-title,.rst-content .wy-alert-danger.seealso .admonition-title,.rst-content .wy-alert-danger.seealso .wy-alert-title,.rst-content .wy-alert-danger.tip .admonition-title,.rst-content .wy-alert-danger.tip .wy-alert-title,.rst-content .wy-alert-danger.warning .admonition-title,.rst-content .wy-alert-danger.warning .wy-alert-title,.rst-content .wy-alert.wy-alert-danger .admonition-title,.wy-alert.wy-alert-danger .rst-content .admonition-title,.wy-alert.wy-alert-danger .wy-alert-title{background:#f29f97}.rst-content .admonition-todo,.rst-content .attention,.rst-content .caution,.rst-content .warning,.rst-content .wy-alert-warning.admonition,.rst-content .wy-alert-warning.danger,.rst-content .wy-alert-warning.error,.rst-content .wy-alert-warning.hint,.rst-content .wy-alert-warning.important,.rst-content .wy-alert-warning.note,.rst-content .wy-alert-warning.seealso,.rst-content .wy-alert-warning.tip,.wy-alert.wy-alert-warning{background:#ffedcc}.rst-content .admonition-todo .admonition-title,.rst-content .admonition-todo .wy-alert-title,.rst-content .attention .admonition-title,.rst-content .attention .wy-alert-title,.rst-content .caution .admonition-title,.rst-content .caution .wy-alert-title,.rst-content .warning .admonition-title,.rst-content .warning .wy-alert-title,.rst-content .wy-alert-warning.admonition .admonition-title,.rst-content .wy-alert-warning.admonition .wy-alert-title,.rst-content .wy-alert-warning.danger .admonition-title,.rst-content .wy-alert-warning.danger .wy-alert-title,.rst-content .wy-alert-warning.error .admonition-title,.rst-content .wy-alert-warning.error .wy-alert-title,.rst-content .wy-alert-warning.hint .admonition-title,.rst-content .wy-alert-warning.hint .wy-alert-title,.rst-content .wy-alert-warning.important .admonition-title,.rst-content .wy-alert-warning.important .wy-alert-title,.rst-content .wy-alert-warning.note .admonition-title,.rst-content .wy-alert-warning.note .wy-alert-title,.rst-content .wy-alert-warning.seealso .admonition-title,.rst-content .wy-alert-warning.seealso .wy-alert-title,.rst-content .wy-alert-warning.tip .admonition-title,.rst-content .wy-alert-warning.tip .wy-alert-title,.rst-content .wy-alert.wy-alert-warning .admonition-title,.wy-alert.wy-alert-warning .rst-content .admonition-title,.wy-alert.wy-alert-warning .wy-alert-title{background:#f0b37e}.rst-content .note,.rst-content .seealso,.rst-content .wy-alert-info.admonition,.rst-content .wy-alert-info.admonition-todo,.rst-content .wy-alert-info.attention,.rst-content .wy-alert-info.caution,.rst-content .wy-alert-info.danger,.rst-content .wy-alert-info.error,.rst-content .wy-alert-info.hint,.rst-content .wy-alert-info.important,.rst-content .wy-alert-info.tip,.rst-content .wy-alert-info.warning,.wy-alert.wy-alert-info{background:#e7f2fa}.rst-content .note .admonition-title,.rst-content .note .wy-alert-title,.rst-content .seealso .admonition-title,.rst-content .seealso .wy-alert-title,.rst-content .wy-alert-info.admonition-todo .admonition-title,.rst-content .wy-alert-info.admonition-todo .wy-alert-title,.rst-content .wy-alert-info.admonition .admonition-title,.rst-content .wy-alert-info.admonition .wy-alert-title,.rst-content .wy-alert-info.attention .admonition-title,.rst-content .wy-alert-info.attention .wy-alert-title,.rst-content .wy-alert-info.caution .admonition-title,.rst-content .wy-alert-info.caution .wy-alert-title,.rst-content .wy-alert-info.danger .admonition-title,.rst-content .wy-alert-info.danger .wy-alert-title,.rst-content .wy-alert-info.error .admonition-title,.rst-content .wy-alert-info.error .wy-alert-title,.rst-content .wy-alert-info.hint .admonition-title,.rst-content .wy-alert-info.hint .wy-alert-title,.rst-content .wy-alert-info.important .admonition-title,.rst-content .wy-alert-info.important .wy-alert-title,.rst-content .wy-alert-info.tip .admonition-title,.rst-content .wy-alert-info.tip .wy-alert-title,.rst-content .wy-alert-info.warning .admonition-title,.rst-content .wy-alert-info.warning .wy-alert-title,.rst-content .wy-alert.wy-alert-info .admonition-title,.wy-alert.wy-alert-info .rst-content .admonition-title,.wy-alert.wy-alert-info .wy-alert-title{background:#6ab0de}.rst-content .hint,.rst-content .important,.rst-content .tip,.rst-content .wy-alert-success.admonition,.rst-content .wy-alert-success.admonition-todo,.rst-content .wy-alert-success.attention,.rst-content .wy-alert-success.caution,.rst-content .wy-alert-success.danger,.rst-content .wy-alert-success.error,.rst-content .wy-alert-success.note,.rst-content .wy-alert-success.seealso,.rst-content .wy-alert-success.warning,.wy-alert.wy-alert-success{background:#dbfaf4}.rst-content .hint .admonition-title,.rst-content .hint .wy-alert-title,.rst-content .important .admonition-title,.rst-content .important .wy-alert-title,.rst-content .tip .admonition-title,.rst-content .tip .wy-alert-title,.rst-content .wy-alert-success.admonition-todo .admonition-title,.rst-content .wy-alert-success.admonition-todo .wy-alert-title,.rst-content .wy-alert-success.admonition .admonition-title,.rst-content .wy-alert-success.admonition .wy-alert-title,.rst-content .wy-alert-success.attention .admonition-title,.rst-content .wy-alert-success.attention .wy-alert-title,.rst-content .wy-alert-success.caution .admonition-title,.rst-content .wy-alert-success.caution .wy-alert-title,.rst-content .wy-alert-success.danger .admonition-title,.rst-content .wy-alert-success.danger .wy-alert-title,.rst-content .wy-alert-success.error .admonition-title,.rst-content .wy-alert-success.error .wy-alert-title,.rst-content .wy-alert-success.note .admonition-title,.rst-content .wy-alert-success.note .wy-alert-title,.rst-content .wy-alert-success.seealso .admonition-title,.rst-content .wy-alert-success.seealso .wy-alert-title,.rst-content .wy-alert-success.warning .admonition-title,.rst-content .wy-alert-success.warning .wy-alert-title,.rst-content .wy-alert.wy-alert-success .admonition-title,.wy-alert.wy-alert-success .rst-content .admonition-title,.wy-alert.wy-alert-success .wy-alert-title{background:#1abc9c}.rst-content .wy-alert-neutral.admonition,.rst-content .wy-alert-neutral.admonition-todo,.rst-content .wy-alert-neutral.attention,.rst-content .wy-alert-neutral.caution,.rst-content .wy-alert-neutral.danger,.rst-content .wy-alert-neutral.error,.rst-content .wy-alert-neutral.hint,.rst-content .wy-alert-neutral.important,.rst-content .wy-alert-neutral.note,.rst-content .wy-alert-neutral.seealso,.rst-content .wy-alert-neutral.tip,.rst-content .wy-alert-neutral.warning,.wy-alert.wy-alert-neutral{background:#f3f6f6}.rst-content .wy-alert-neutral.admonition-todo .admonition-title,.rst-content .wy-alert-neutral.admonition-todo .wy-alert-title,.rst-content .wy-alert-neutral.admonition .admonition-title,.rst-content .wy-alert-neutral.admonition .wy-alert-title,.rst-content .wy-alert-neutral.attention .admonition-title,.rst-content .wy-alert-neutral.attention .wy-alert-title,.rst-content .wy-alert-neutral.caution .admonition-title,.rst-content .wy-alert-neutral.caution .wy-alert-title,.rst-content .wy-alert-neutral.danger .admonition-title,.rst-content .wy-alert-neutral.danger .wy-alert-title,.rst-content .wy-alert-neutral.error .admonition-title,.rst-content .wy-alert-neutral.error .wy-alert-title,.rst-content .wy-alert-neutral.hint .admonition-title,.rst-content .wy-alert-neutral.hint .wy-alert-title,.rst-content .wy-alert-neutral.important .admonition-title,.rst-content .wy-alert-neutral.important .wy-alert-title,.rst-content .wy-alert-neutral.note .admonition-title,.rst-content .wy-alert-neutral.note .wy-alert-title,.rst-content .wy-alert-neutral.seealso .admonition-title,.rst-content .wy-alert-neutral.seealso .wy-alert-title,.rst-content .wy-alert-neutral.tip .admonition-title,.rst-content .wy-alert-neutral.tip .wy-alert-title,.rst-content .wy-alert-neutral.warning .admonition-title,.rst-content .wy-alert-neutral.warning .wy-alert-title,.rst-content .wy-alert.wy-alert-neutral .admonition-title,.wy-alert.wy-alert-neutral .rst-content .admonition-title,.wy-alert.wy-alert-neutral .wy-alert-title{color:#404040;background:#e1e4e5}.rst-content .wy-alert-neutral.admonition-todo a,.rst-content .wy-alert-neutral.admonition a,.rst-content .wy-alert-neutral.attention a,.rst-content .wy-alert-neutral.caution a,.rst-content .wy-alert-neutral.danger a,.rst-content .wy-alert-neutral.error a,.rst-content .wy-alert-neutral.hint a,.rst-content .wy-alert-neutral.important a,.rst-content .wy-alert-neutral.note a,.rst-content .wy-alert-neutral.seealso a,.rst-content .wy-alert-neutral.tip a,.rst-content .wy-alert-neutral.warning a,.wy-alert.wy-alert-neutral a{color:#2980b9}.rst-content .admonition-todo p:last-child,.rst-content .admonition p:last-child,.rst-content .attention p:last-child,.rst-content .caution p:last-child,.rst-content .danger p:last-child,.rst-content .error p:last-child,.rst-content .hint p:last-child,.rst-content .important p:last-child,.rst-content .note p:last-child,.rst-content .seealso p:last-child,.rst-content .tip p:last-child,.rst-content .warning p:last-child,.wy-alert p:last-child{margin-bottom:0}.wy-tray-container{position:fixed;bottom:0;left:0;z-index:600}.wy-tray-container li{display:block;width:300px;background:transparent;color:#fff;text-align:center;box-shadow:0 5px 5px 0 rgba(0,0,0,.1);padding:0 24px;min-width:20%;opacity:0;height:0;line-height:56px;overflow:hidden;-webkit-transition:all .3s ease-in;-moz-transition:all .3s ease-in;transition:all .3s ease-in}.wy-tray-container li.wy-tray-item-success{background:#27ae60}.wy-tray-container li.wy-tray-item-info{background:#2980b9}.wy-tray-container li.wy-tray-item-warning{background:#e67e22}.wy-tray-container li.wy-tray-item-danger{background:#e74c3c}.wy-tray-container li.on{opacity:1;height:56px}@media screen and (max-width:768px){.wy-tray-container{bottom:auto;top:0;width:100%}.wy-tray-container li{width:100%}}button{font-size:100%;margin:0;vertical-align:baseline;*vertical-align:middle;cursor:pointer;line-height:normal;-webkit-appearance:button;*overflow:visible}button::-moz-focus-inner,input::-moz-focus-inner{border:0;padding:0}button[disabled]{cursor:default}.btn{display:inline-block;border-radius:2px;line-height:normal;white-space:nowrap;text-align:center;cursor:pointer;font-size:100%;padding:6px 12px 8px;color:#fff;border:1px solid rgba(0,0,0,.1);background-color:#27ae60;text-decoration:none;font-weight:400;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;box-shadow:inset 0 1px 2px -1px hsla(0,0%,100%,.5),inset 0 -2px 0 0 rgba(0,0,0,.1);outline-none:false;vertical-align:middle;*display:inline;zoom:1;-webkit-user-drag:none;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;-webkit-transition:all .1s linear;-moz-transition:all .1s linear;transition:all .1s linear}.btn-hover{background:#2e8ece;color:#fff}.btn:hover{background:#2cc36b;color:#fff}.btn:focus{background:#2cc36b;outline:0}.btn:active{box-shadow:inset 0 -1px 0 0 rgba(0,0,0,.05),inset 0 2px 0 0 rgba(0,0,0,.1);padding:8px 12px 6px}.btn:visited{color:#fff}.btn-disabled,.btn-disabled:active,.btn-disabled:focus,.btn-disabled:hover,.btn:disabled{background-image:none;filter:progid:DXImageTransform.Microsoft.gradient(enabled = false);filter:alpha(opacity=40);opacity:.4;cursor:not-allowed;box-shadow:none}.btn::-moz-focus-inner{padding:0;border:0}.btn-small{font-size:80%}.btn-info{background-color:#2980b9!important}.btn-info:hover{background-color:#2e8ece!important}.btn-neutral{background-color:#f3f6f6!important;color:#404040!important}.btn-neutral:hover{background-color:#e5ebeb!important;color:#404040}.btn-neutral:visited{color:#404040!important}.btn-success{background-color:#27ae60!important}.btn-success:hover{background-color:#295!important}.btn-danger{background-color:#e74c3c!important}.btn-danger:hover{background-color:#ea6153!important}.btn-warning{background-color:#e67e22!important}.btn-warning:hover{background-color:#e98b39!important}.btn-invert{background-color:#222}.btn-invert:hover{background-color:#2f2f2f!important}.btn-link{background-color:transparent!important;color:#2980b9;box-shadow:none;border-color:transparent!important}.btn-link:active,.btn-link:hover{background-color:transparent!important;color:#409ad5!important;box-shadow:none}.btn-link:visited{color:#9b59b6}.wy-btn-group .btn,.wy-control .btn{vertical-align:middle}.wy-btn-group{margin-bottom:24px;*zoom:1}.wy-btn-group:after,.wy-btn-group:before{display:table;content:""}.wy-btn-group:after{clear:both}.wy-dropdown{position:relative;display:inline-block}.wy-dropdown-active .wy-dropdown-menu{display:block}.wy-dropdown-menu{position:absolute;left:0;display:none;float:left;top:100%;min-width:100%;background:#fcfcfc;z-index:100;border:1px solid #cfd7dd;box-shadow:0 2px 2px 0 rgba(0,0,0,.1);padding:12px}.wy-dropdown-menu>dd>a{display:block;clear:both;color:#404040;white-space:nowrap;font-size:90%;padding:0 12px;cursor:pointer}.wy-dropdown-menu>dd>a:hover{background:#2980b9;color:#fff}.wy-dropdown-menu>dd.divider{border-top:1px solid #cfd7dd;margin:6px 0}.wy-dropdown-menu>dd.search{padding-bottom:12px}.wy-dropdown-menu>dd.search input[type=search]{width:100%}.wy-dropdown-menu>dd.call-to-action{background:#e3e3e3;text-transform:uppercase;font-weight:500;font-size:80%}.wy-dropdown-menu>dd.call-to-action:hover{background:#e3e3e3}.wy-dropdown-menu>dd.call-to-action .btn{color:#fff}.wy-dropdown.wy-dropdown-up .wy-dropdown-menu{bottom:100%;top:auto;left:auto;right:0}.wy-dropdown.wy-dropdown-bubble .wy-dropdown-menu{background:#fcfcfc;margin-top:2px}.wy-dropdown.wy-dropdown-bubble .wy-dropdown-menu a{padding:6px 12px}.wy-dropdown.wy-dropdown-bubble .wy-dropdown-menu a:hover{background:#2980b9;color:#fff}.wy-dropdown.wy-dropdown-left .wy-dropdown-menu{right:0;left:auto;text-align:right}.wy-dropdown-arrow:before{content:" ";border-bottom:5px solid #f5f5f5;border-left:5px solid transparent;border-right:5px solid transparent;position:absolute;display:block;top:-4px;left:50%;margin-left:-3px}.wy-dropdown-arrow.wy-dropdown-arrow-left:before{left:11px}.wy-form-stacked select{display:block}.wy-form-aligned .wy-help-inline,.wy-form-aligned input,.wy-form-aligned label,.wy-form-aligned select,.wy-form-aligned textarea{display:inline-block;*display:inline;*zoom:1;vertical-align:middle}.wy-form-aligned .wy-control-group>label{display:inline-block;vertical-align:middle;width:10em;margin:6px 12px 0 0;float:left}.wy-form-aligned .wy-control{float:left}.wy-form-aligned .wy-control label{display:block}.wy-form-aligned .wy-control select{margin-top:6px}fieldset{margin:0}fieldset,legend{border:0;padding:0}legend{width:100%;white-space:normal;margin-bottom:24px;font-size:150%;*margin-left:-7px}label,legend{display:block}label{margin:0 0 .3125em;color:#333;font-size:90%}input,select,textarea{font-size:100%;margin:0;vertical-align:baseline;*vertical-align:middle}.wy-control-group{margin-bottom:24px;max-width:1200px;margin-left:auto;margin-right:auto;*zoom:1}.wy-control-group:after,.wy-control-group:before{display:table;content:""}.wy-control-group:after{clear:both}.wy-control-group.wy-control-group-required>label:after{content:" *";color:#e74c3c}.wy-control-group .wy-form-full,.wy-control-group .wy-form-halves,.wy-control-group .wy-form-thirds{padding-bottom:12px}.wy-control-group .wy-form-full input[type=color],.wy-control-group .wy-form-full input[type=date],.wy-control-group .wy-form-full input[type=datetime-local],.wy-control-group .wy-form-full input[type=datetime],.wy-control-group .wy-form-full input[type=email],.wy-control-group .wy-form-full input[type=month],.wy-control-group .wy-form-full input[type=number],.wy-control-group .wy-form-full input[type=password],.wy-control-group .wy-form-full input[type=search],.wy-control-group .wy-form-full input[type=tel],.wy-control-group .wy-form-full input[type=text],.wy-control-group .wy-form-full input[type=time],.wy-control-group .wy-form-full input[type=url],.wy-control-group .wy-form-full input[type=week],.wy-control-group .wy-form-full select,.wy-control-group .wy-form-halves input[type=color],.wy-control-group .wy-form-halves input[type=date],.wy-control-group .wy-form-halves input[type=datetime-local],.wy-control-group .wy-form-halves input[type=datetime],.wy-control-group .wy-form-halves input[type=email],.wy-control-group .wy-form-halves input[type=month],.wy-control-group .wy-form-halves input[type=number],.wy-control-group .wy-form-halves input[type=password],.wy-control-group .wy-form-halves input[type=search],.wy-control-group .wy-form-halves input[type=tel],.wy-control-group .wy-form-halves input[type=text],.wy-control-group .wy-form-halves input[type=time],.wy-control-group .wy-form-halves input[type=url],.wy-control-group .wy-form-halves input[type=week],.wy-control-group .wy-form-halves select,.wy-control-group .wy-form-thirds input[type=color],.wy-control-group .wy-form-thirds input[type=date],.wy-control-group .wy-form-thirds input[type=datetime-local],.wy-control-group .wy-form-thirds input[type=datetime],.wy-control-group .wy-form-thirds input[type=email],.wy-control-group .wy-form-thirds input[type=month],.wy-control-group .wy-form-thirds input[type=number],.wy-control-group .wy-form-thirds input[type=password],.wy-control-group .wy-form-thirds input[type=search],.wy-control-group .wy-form-thirds input[type=tel],.wy-control-group .wy-form-thirds input[type=text],.wy-control-group .wy-form-thirds input[type=time],.wy-control-group .wy-form-thirds input[type=url],.wy-control-group .wy-form-thirds input[type=week],.wy-control-group .wy-form-thirds select{width:100%}.wy-control-group .wy-form-full{float:left;display:block;width:100%;margin-right:0}.wy-control-group .wy-form-full:last-child{margin-right:0}.wy-control-group .wy-form-halves{float:left;display:block;margin-right:2.35765%;width:48.82117%}.wy-control-group .wy-form-halves:last-child,.wy-control-group .wy-form-halves:nth-of-type(2n){margin-right:0}.wy-control-group .wy-form-halves:nth-of-type(odd){clear:left}.wy-control-group .wy-form-thirds{float:left;display:block;margin-right:2.35765%;width:31.76157%}.wy-control-group .wy-form-thirds:last-child,.wy-control-group .wy-form-thirds:nth-of-type(3n){margin-right:0}.wy-control-group .wy-form-thirds:nth-of-type(3n+1){clear:left}.wy-control-group.wy-control-group-no-input .wy-control,.wy-control-no-input{margin:6px 0 0;font-size:90%}.wy-control-no-input{display:inline-block}.wy-control-group.fluid-input input[type=color],.wy-control-group.fluid-input input[type=date],.wy-control-group.fluid-input input[type=datetime-local],.wy-control-group.fluid-input input[type=datetime],.wy-control-group.fluid-input input[type=email],.wy-control-group.fluid-input input[type=month],.wy-control-group.fluid-input input[type=number],.wy-control-group.fluid-input input[type=password],.wy-control-group.fluid-input input[type=search],.wy-control-group.fluid-input input[type=tel],.wy-control-group.fluid-input input[type=text],.wy-control-group.fluid-input input[type=time],.wy-control-group.fluid-input input[type=url],.wy-control-group.fluid-input input[type=week]{width:100%}.wy-form-message-inline{padding-left:.3em;color:#666;font-size:90%}.wy-form-message{display:block;color:#999;font-size:70%;margin-top:.3125em;font-style:italic}.wy-form-message p{font-size:inherit;font-style:italic;margin-bottom:6px}.wy-form-message p:last-child{margin-bottom:0}input{line-height:normal}input[type=button],input[type=reset],input[type=submit]{-webkit-appearance:button;cursor:pointer;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;*overflow:visible}input[type=color],input[type=date],input[type=datetime-local],input[type=datetime],input[type=email],input[type=month],input[type=number],input[type=password],input[type=search],input[type=tel],input[type=text],input[type=time],input[type=url],input[type=week]{-webkit-appearance:none;padding:6px;display:inline-block;border:1px solid #ccc;font-size:80%;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;box-shadow:inset 0 1px 3px #ddd;border-radius:0;-webkit-transition:border .3s linear;-moz-transition:border .3s linear;transition:border .3s linear}input[type=datetime-local]{padding:.34375em .625em}input[disabled]{cursor:default}input[type=checkbox],input[type=radio]{padding:0;margin-right:.3125em;*height:13px;*width:13px}input[type=checkbox],input[type=radio],input[type=search]{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}input[type=search]::-webkit-search-cancel-button,input[type=search]::-webkit-search-decoration{-webkit-appearance:none}input[type=color]:focus,input[type=date]:focus,input[type=datetime-local]:focus,input[type=datetime]:focus,input[type=email]:focus,input[type=month]:focus,input[type=number]:focus,input[type=password]:focus,input[type=search]:focus,input[type=tel]:focus,input[type=text]:focus,input[type=time]:focus,input[type=url]:focus,input[type=week]:focus{outline:0;outline:thin dotted\9;border-color:#333}input.no-focus:focus{border-color:#ccc!important}input[type=checkbox]:focus,input[type=file]:focus,input[type=radio]:focus{outline:thin dotted #333;outline:1px auto #129fea}input[type=color][disabled],input[type=date][disabled],input[type=datetime-local][disabled],input[type=datetime][disabled],input[type=email][disabled],input[type=month][disabled],input[type=number][disabled],input[type=password][disabled],input[type=search][disabled],input[type=tel][disabled],input[type=text][disabled],input[type=time][disabled],input[type=url][disabled],input[type=week][disabled]{cursor:not-allowed;background-color:#fafafa}input:focus:invalid,select:focus:invalid,textarea:focus:invalid{color:#e74c3c;border:1px solid #e74c3c}input:focus:invalid:focus,select:focus:invalid:focus,textarea:focus:invalid:focus{border-color:#e74c3c}input[type=checkbox]:focus:invalid:focus,input[type=file]:focus:invalid:focus,input[type=radio]:focus:invalid:focus{outline-color:#e74c3c}input.wy-input-large{padding:12px;font-size:100%}textarea{overflow:auto;vertical-align:top;width:100%;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif}select,textarea{padding:.5em .625em;display:inline-block;border:1px solid #ccc;font-size:80%;box-shadow:inset 0 1px 3px #ddd;-webkit-transition:border .3s linear;-moz-transition:border .3s linear;transition:border .3s linear}select{border:1px solid #ccc;background-color:#fff}select[multiple]{height:auto}select:focus,textarea:focus{outline:0}input[readonly],select[disabled],select[readonly],textarea[disabled],textarea[readonly]{cursor:not-allowed;background-color:#fafafa}input[type=checkbox][disabled],input[type=radio][disabled]{cursor:not-allowed}.wy-checkbox,.wy-radio{margin:6px 0;color:#404040;display:block}.wy-checkbox input,.wy-radio input{vertical-align:baseline}.wy-form-message-inline{display:inline-block;*display:inline;*zoom:1;vertical-align:middle}.wy-input-prefix,.wy-input-suffix{white-space:nowrap;padding:6px}.wy-input-prefix .wy-input-context,.wy-input-suffix .wy-input-context{line-height:27px;padding:0 8px;display:inline-block;font-size:80%;background-color:#f3f6f6;border:1px solid #ccc;color:#999}.wy-input-suffix .wy-input-context{border-left:0}.wy-input-prefix .wy-input-context{border-right:0}.wy-switch{position:relative;display:block;height:24px;margin-top:12px;cursor:pointer}.wy-switch:before{left:0;top:0;width:36px;height:12px;background:#ccc}.wy-switch:after,.wy-switch:before{position:absolute;content:"";display:block;border-radius:4px;-webkit-transition:all .2s ease-in-out;-moz-transition:all .2s ease-in-out;transition:all .2s ease-in-out}.wy-switch:after{width:18px;height:18px;background:#999;left:-3px;top:-3px}.wy-switch span{position:absolute;left:48px;display:block;font-size:12px;color:#ccc;line-height:1}.wy-switch.active:before{background:#1e8449}.wy-switch.active:after{left:24px;background:#27ae60}.wy-switch.disabled{cursor:not-allowed;opacity:.8}.wy-control-group.wy-control-group-error .wy-form-message,.wy-control-group.wy-control-group-error>label{color:#e74c3c}.wy-control-group.wy-control-group-error input[type=color],.wy-control-group.wy-control-group-error input[type=date],.wy-control-group.wy-control-group-error input[type=datetime-local],.wy-control-group.wy-control-group-error input[type=datetime],.wy-control-group.wy-control-group-error input[type=email],.wy-control-group.wy-control-group-error input[type=month],.wy-control-group.wy-control-group-error input[type=number],.wy-control-group.wy-control-group-error input[type=password],.wy-control-group.wy-control-group-error input[type=search],.wy-control-group.wy-control-group-error input[type=tel],.wy-control-group.wy-control-group-error input[type=text],.wy-control-group.wy-control-group-error input[type=time],.wy-control-group.wy-control-group-error input[type=url],.wy-control-group.wy-control-group-error input[type=week],.wy-control-group.wy-control-group-error textarea{border:1px solid #e74c3c}.wy-inline-validate{white-space:nowrap}.wy-inline-validate .wy-input-context{padding:.5em .625em;display:inline-block;font-size:80%}.wy-inline-validate.wy-inline-validate-success .wy-input-context{color:#27ae60}.wy-inline-validate.wy-inline-validate-danger .wy-input-context{color:#e74c3c}.wy-inline-validate.wy-inline-validate-warning .wy-input-context{color:#e67e22}.wy-inline-validate.wy-inline-validate-info .wy-input-context{color:#2980b9}.rotate-90{-webkit-transform:rotate(90deg);-moz-transform:rotate(90deg);-ms-transform:rotate(90deg);-o-transform:rotate(90deg);transform:rotate(90deg)}.rotate-180{-webkit-transform:rotate(180deg);-moz-transform:rotate(180deg);-ms-transform:rotate(180deg);-o-transform:rotate(180deg);transform:rotate(180deg)}.rotate-270{-webkit-transform:rotate(270deg);-moz-transform:rotate(270deg);-ms-transform:rotate(270deg);-o-transform:rotate(270deg);transform:rotate(270deg)}.mirror{-webkit-transform:scaleX(-1);-moz-transform:scaleX(-1);-ms-transform:scaleX(-1);-o-transform:scaleX(-1);transform:scaleX(-1)}.mirror.rotate-90{-webkit-transform:scaleX(-1) rotate(90deg);-moz-transform:scaleX(-1) rotate(90deg);-ms-transform:scaleX(-1) rotate(90deg);-o-transform:scaleX(-1) rotate(90deg);transform:scaleX(-1) rotate(90deg)}.mirror.rotate-180{-webkit-transform:scaleX(-1) rotate(180deg);-moz-transform:scaleX(-1) rotate(180deg);-ms-transform:scaleX(-1) rotate(180deg);-o-transform:scaleX(-1) rotate(180deg);transform:scaleX(-1) rotate(180deg)}.mirror.rotate-270{-webkit-transform:scaleX(-1) rotate(270deg);-moz-transform:scaleX(-1) rotate(270deg);-ms-transform:scaleX(-1) rotate(270deg);-o-transform:scaleX(-1) rotate(270deg);transform:scaleX(-1) rotate(270deg)}@media only screen and (max-width:480px){.wy-form button[type=submit]{margin:.7em 0 0}.wy-form input[type=color],.wy-form input[type=date],.wy-form input[type=datetime-local],.wy-form input[type=datetime],.wy-form input[type=email],.wy-form input[type=month],.wy-form input[type=number],.wy-form input[type=password],.wy-form input[type=search],.wy-form input[type=tel],.wy-form input[type=text],.wy-form input[type=time],.wy-form input[type=url],.wy-form input[type=week],.wy-form label{margin-bottom:.3em;display:block}.wy-form input[type=color],.wy-form input[type=date],.wy-form input[type=datetime-local],.wy-form input[type=datetime],.wy-form input[type=email],.wy-form input[type=month],.wy-form input[type=number],.wy-form input[type=password],.wy-form input[type=search],.wy-form input[type=tel],.wy-form input[type=time],.wy-form input[type=url],.wy-form input[type=week]{margin-bottom:0}.wy-form-aligned .wy-control-group label{margin-bottom:.3em;text-align:left;display:block;width:100%}.wy-form-aligned .wy-control{margin:1.5em 0 0}.wy-form-message,.wy-form-message-inline,.wy-form .wy-help-inline{display:block;font-size:80%;padding:6px 0}}@media screen and (max-width:768px){.tablet-hide{display:none}}@media screen and (max-width:480px){.mobile-hide{display:none}}.float-left{float:left}.float-right{float:right}.full-width{width:100%}.rst-content table.docutils,.rst-content table.field-list,.wy-table{border-collapse:collapse;border-spacing:0;empty-cells:show;margin-bottom:24px}.rst-content table.docutils caption,.rst-content table.field-list caption,.wy-table caption{color:#000;font:italic 85%/1 arial,sans-serif;padding:1em 0;text-align:center}.rst-content table.docutils td,.rst-content table.docutils th,.rst-content table.field-list td,.rst-content table.field-list th,.wy-table td,.wy-table th{font-size:90%;margin:0;overflow:visible;padding:8px 16px}.rst-content table.docutils td:first-child,.rst-content table.docutils th:first-child,.rst-content table.field-list td:first-child,.rst-content table.field-list th:first-child,.wy-table td:first-child,.wy-table th:first-child{border-left-width:0}.rst-content table.docutils thead,.rst-content table.field-list thead,.wy-table thead{color:#000;text-align:left;vertical-align:bottom;white-space:nowrap}.rst-content table.docutils thead th,.rst-content table.field-list thead th,.wy-table thead th{font-weight:700;border-bottom:2px solid #e1e4e5}.rst-content table.docutils td,.rst-content table.field-list td,.wy-table td{background-color:transparent;vertical-align:middle}.rst-content table.docutils td p,.rst-content table.field-list td p,.wy-table td p{line-height:18px}.rst-content table.docutils td p:last-child,.rst-content table.field-list td p:last-child,.wy-table td p:last-child{margin-bottom:0}.rst-content table.docutils .wy-table-cell-min,.rst-content table.field-list .wy-table-cell-min,.wy-table .wy-table-cell-min{width:1%;padding-right:0}.rst-content table.docutils .wy-table-cell-min input[type=checkbox],.rst-content table.field-list .wy-table-cell-min input[type=checkbox],.wy-table .wy-table-cell-min input[type=checkbox]{margin:0}.wy-table-secondary{color:grey;font-size:90%}.wy-table-tertiary{color:grey;font-size:80%}.rst-content table.docutils:not(.field-list) tr:nth-child(2n-1) td,.wy-table-backed,.wy-table-odd td,.wy-table-striped tr:nth-child(2n-1) td{background-color:#f3f6f6}.rst-content table.docutils,.wy-table-bordered-all{border:1px solid #e1e4e5}.rst-content table.docutils td,.wy-table-bordered-all td{border-bottom:1px solid #e1e4e5;border-left:1px solid #e1e4e5}.rst-content table.docutils tbody>tr:last-child td,.wy-table-bordered-all tbody>tr:last-child td{border-bottom-width:0}.wy-table-bordered{border:1px solid #e1e4e5}.wy-table-bordered-rows td{border-bottom:1px solid #e1e4e5}.wy-table-bordered-rows tbody>tr:last-child td{border-bottom-width:0}.wy-table-horizontal td,.wy-table-horizontal th{border-width:0 0 1px;border-bottom:1px solid #e1e4e5}.wy-table-horizontal tbody>tr:last-child td{border-bottom-width:0}.wy-table-responsive{margin-bottom:24px;max-width:100%;overflow:auto}.wy-table-responsive table{margin-bottom:0!important}.wy-table-responsive table td,.wy-table-responsive table th{white-space:nowrap}a{color:#2980b9;text-decoration:none;cursor:pointer}a:hover{color:#3091d1}a:visited{color:#9b59b6}html{height:100%}body,html{overflow-x:hidden}body{font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;font-weight:400;color:#404040;min-height:100%;background:#edf0f2}.wy-text-left{text-align:left}.wy-text-center{text-align:center}.wy-text-right{text-align:right}.wy-text-large{font-size:120%}.wy-text-normal{font-size:100%}.wy-text-small,small{font-size:80%}.wy-text-strike{text-decoration:line-through}.wy-text-warning{color:#e67e22!important}a.wy-text-warning:hover{color:#eb9950!important}.wy-text-info{color:#2980b9!important}a.wy-text-info:hover{color:#409ad5!important}.wy-text-success{color:#27ae60!important}a.wy-text-success:hover{color:#36d278!important}.wy-text-danger{color:#e74c3c!important}a.wy-text-danger:hover{color:#ed7669!important}.wy-text-neutral{color:#404040!important}a.wy-text-neutral:hover{color:#595959!important}.rst-content .toctree-wrapper>p.caption,h1,h2,h3,h4,h5,h6,legend{margin-top:0;font-weight:700;font-family:Roboto Slab,ff-tisa-web-pro,Georgia,Arial,sans-serif}p{line-height:24px;font-size:16px;margin:0 0 24px}h1{font-size:175%}.rst-content .toctree-wrapper>p.caption,h2{font-size:150%}h3{font-size:125%}h4{font-size:115%}h5{font-size:110%}h6{font-size:100%}hr{display:block;height:1px;border:0;border-top:1px solid #e1e4e5;margin:24px 0;padding:0}.rst-content code,.rst-content tt,code{white-space:nowrap;max-width:100%;background:#fff;border:1px solid #e1e4e5;font-size:75%;padding:0 5px;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;color:#e74c3c;overflow-x:auto}.rst-content tt.code-large,code.code-large{font-size:90%}.rst-content .section ul,.rst-content .toctree-wrapper ul,.rst-content section ul,.wy-plain-list-disc,article ul{list-style:disc;line-height:24px;margin-bottom:24px}.rst-content .section ul li,.rst-content .toctree-wrapper ul li,.rst-content section ul li,.wy-plain-list-disc li,article ul li{list-style:disc;margin-left:24px}.rst-content .section ul li p:last-child,.rst-content .section ul li ul,.rst-content .toctree-wrapper ul li p:last-child,.rst-content .toctree-wrapper ul li ul,.rst-content section ul li p:last-child,.rst-content section ul li ul,.wy-plain-list-disc li p:last-child,.wy-plain-list-disc li ul,article ul li p:last-child,article ul li ul{margin-bottom:0}.rst-content .section ul li li,.rst-content .toctree-wrapper ul li li,.rst-content section ul li li,.wy-plain-list-disc li li,article ul li li{list-style:circle}.rst-content .section ul li li li,.rst-content .toctree-wrapper ul li li li,.rst-content section ul li li li,.wy-plain-list-disc li li li,article ul li li li{list-style:square}.rst-content .section ul li ol li,.rst-content .toctree-wrapper ul li ol li,.rst-content section ul li ol li,.wy-plain-list-disc li ol li,article ul li ol li{list-style:decimal}.rst-content .section ol,.rst-content .section ol.arabic,.rst-content .toctree-wrapper ol,.rst-content .toctree-wrapper ol.arabic,.rst-content section ol,.rst-content section ol.arabic,.wy-plain-list-decimal,article ol{list-style:decimal;line-height:24px;margin-bottom:24px}.rst-content .section ol.arabic li,.rst-content .section ol li,.rst-content .toctree-wrapper ol.arabic li,.rst-content .toctree-wrapper ol li,.rst-content section ol.arabic li,.rst-content section ol li,.wy-plain-list-decimal li,article ol li{list-style:decimal;margin-left:24px}.rst-content .section ol.arabic li ul,.rst-content .section ol li p:last-child,.rst-content .section ol li ul,.rst-content .toctree-wrapper ol.arabic li ul,.rst-content .toctree-wrapper ol li p:last-child,.rst-content .toctree-wrapper ol li ul,.rst-content section ol.arabic li ul,.rst-content section ol li p:last-child,.rst-content section ol li ul,.wy-plain-list-decimal li p:last-child,.wy-plain-list-decimal li ul,article ol li p:last-child,article ol li ul{margin-bottom:0}.rst-content .section ol.arabic li ul li,.rst-content .section ol li ul li,.rst-content .toctree-wrapper ol.arabic li ul li,.rst-content .toctree-wrapper ol li ul li,.rst-content section ol.arabic li ul li,.rst-content section ol li ul li,.wy-plain-list-decimal li ul li,article ol li ul li{list-style:disc}.wy-breadcrumbs{*zoom:1}.wy-breadcrumbs:after,.wy-breadcrumbs:before{display:table;content:""}.wy-breadcrumbs:after{clear:both}.wy-breadcrumbs li{display:inline-block}.wy-breadcrumbs li.wy-breadcrumbs-aside{float:right}.wy-breadcrumbs li a{display:inline-block;padding:5px}.wy-breadcrumbs li a:first-child{padding-left:0}.rst-content .wy-breadcrumbs li tt,.wy-breadcrumbs li .rst-content tt,.wy-breadcrumbs li code{padding:5px;border:none;background:none}.rst-content .wy-breadcrumbs li tt.literal,.wy-breadcrumbs li .rst-content tt.literal,.wy-breadcrumbs li code.literal{color:#404040}.wy-breadcrumbs-extra{margin-bottom:0;color:#b3b3b3;font-size:80%;display:inline-block}@media screen and (max-width:480px){.wy-breadcrumbs-extra,.wy-breadcrumbs li.wy-breadcrumbs-aside{display:none}}@media print{.wy-breadcrumbs li.wy-breadcrumbs-aside{display:none}}html{font-size:16px}.wy-affix{position:fixed;top:1.618em}.wy-menu a:hover{text-decoration:none}.wy-menu-horiz{*zoom:1}.wy-menu-horiz:after,.wy-menu-horiz:before{display:table;content:""}.wy-menu-horiz:after{clear:both}.wy-menu-horiz li,.wy-menu-horiz ul{display:inline-block}.wy-menu-horiz li:hover{background:hsla(0,0%,100%,.1)}.wy-menu-horiz li.divide-left{border-left:1px solid #404040}.wy-menu-horiz li.divide-right{border-right:1px solid #404040}.wy-menu-horiz a{height:32px;display:inline-block;line-height:32px;padding:0 16px}.wy-menu-vertical{width:300px}.wy-menu-vertical header,.wy-menu-vertical p.caption{color:#55a5d9;height:32px;line-height:32px;padding:0 1.618em;margin:12px 0 0;display:block;font-weight:700;text-transform:uppercase;font-size:85%;white-space:nowrap}.wy-menu-vertical ul{margin-bottom:0}.wy-menu-vertical li.divide-top{border-top:1px solid #404040}.wy-menu-vertical li.divide-bottom{border-bottom:1px solid #404040}.wy-menu-vertical li.current{background:#e3e3e3}.wy-menu-vertical li.current a{color:grey;border-right:1px solid #c9c9c9;padding:.4045em 2.427em}.wy-menu-vertical li.current a:hover{background:#d6d6d6}.rst-content .wy-menu-vertical li tt,.wy-menu-vertical li .rst-content tt,.wy-menu-vertical li code{border:none;background:inherit;color:inherit;padding-left:0;padding-right:0}.wy-menu-vertical li button.toctree-expand{display:block;float:left;margin-left:-1.2em;line-height:18px;color:#4d4d4d;border:none;background:none;padding:0}.wy-menu-vertical li.current>a,.wy-menu-vertical li.on a{color:#404040;font-weight:700;position:relative;background:#fcfcfc;border:none;padding:.4045em 1.618em}.wy-menu-vertical li.current>a:hover,.wy-menu-vertical li.on a:hover{background:#fcfcfc}.wy-menu-vertical li.current>a:hover button.toctree-expand,.wy-menu-vertical li.on a:hover button.toctree-expand{color:grey}.wy-menu-vertical li.current>a button.toctree-expand,.wy-menu-vertical li.on a button.toctree-expand{display:block;line-height:18px;color:#333}.wy-menu-vertical li.toctree-l1.current>a{border-bottom:1px solid #c9c9c9;border-top:1px solid #c9c9c9}.wy-menu-vertical .toctree-l1.current .toctree-l2>ul,.wy-menu-vertical .toctree-l2.current .toctree-l3>ul,.wy-menu-vertical .toctree-l3.current .toctree-l4>ul,.wy-menu-vertical .toctree-l4.current .toctree-l5>ul,.wy-menu-vertical .toctree-l5.current .toctree-l6>ul,.wy-menu-vertical .toctree-l6.current .toctree-l7>ul,.wy-menu-vertical .toctree-l7.current .toctree-l8>ul,.wy-menu-vertical .toctree-l8.current .toctree-l9>ul,.wy-menu-vertical .toctree-l9.current .toctree-l10>ul,.wy-menu-vertical .toctree-l10.current .toctree-l11>ul{display:none}.wy-menu-vertical .toctree-l1.current .current.toctree-l2>ul,.wy-menu-vertical .toctree-l2.current .current.toctree-l3>ul,.wy-menu-vertical .toctree-l3.current .current.toctree-l4>ul,.wy-menu-vertical .toctree-l4.current .current.toctree-l5>ul,.wy-menu-vertical .toctree-l5.current .current.toctree-l6>ul,.wy-menu-vertical .toctree-l6.current .current.toctree-l7>ul,.wy-menu-vertical .toctree-l7.current .current.toctree-l8>ul,.wy-menu-vertical .toctree-l8.current .current.toctree-l9>ul,.wy-menu-vertical .toctree-l9.current .current.toctree-l10>ul,.wy-menu-vertical .toctree-l10.current .current.toctree-l11>ul{display:block}.wy-menu-vertical li.toctree-l3,.wy-menu-vertical li.toctree-l4{font-size:.9em}.wy-menu-vertical li.toctree-l2 a,.wy-menu-vertical li.toctree-l3 a,.wy-menu-vertical li.toctree-l4 a,.wy-menu-vertical li.toctree-l5 a,.wy-menu-vertical li.toctree-l6 a,.wy-menu-vertical li.toctree-l7 a,.wy-menu-vertical li.toctree-l8 a,.wy-menu-vertical li.toctree-l9 a,.wy-menu-vertical li.toctree-l10 a{color:#404040}.wy-menu-vertical li.toctree-l2 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l3 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l4 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l5 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l6 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l7 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l8 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l9 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l10 a:hover button.toctree-expand{color:grey}.wy-menu-vertical li.toctree-l2.current li.toctree-l3>a,.wy-menu-vertical li.toctree-l3.current li.toctree-l4>a,.wy-menu-vertical li.toctree-l4.current li.toctree-l5>a,.wy-menu-vertical li.toctree-l5.current li.toctree-l6>a,.wy-menu-vertical li.toctree-l6.current li.toctree-l7>a,.wy-menu-vertical li.toctree-l7.current li.toctree-l8>a,.wy-menu-vertical li.toctree-l8.current li.toctree-l9>a,.wy-menu-vertical li.toctree-l9.current li.toctree-l10>a,.wy-menu-vertical li.toctree-l10.current li.toctree-l11>a{display:block}.wy-menu-vertical li.toctree-l2.current>a{padding:.4045em 2.427em}.wy-menu-vertical li.toctree-l2.current li.toctree-l3>a{padding:.4045em 1.618em .4045em 4.045em}.wy-menu-vertical li.toctree-l3.current>a{padding:.4045em 4.045em}.wy-menu-vertical li.toctree-l3.current li.toctree-l4>a{padding:.4045em 1.618em .4045em 5.663em}.wy-menu-vertical li.toctree-l4.current>a{padding:.4045em 5.663em}.wy-menu-vertical li.toctree-l4.current li.toctree-l5>a{padding:.4045em 1.618em .4045em 7.281em}.wy-menu-vertical li.toctree-l5.current>a{padding:.4045em 7.281em}.wy-menu-vertical li.toctree-l5.current li.toctree-l6>a{padding:.4045em 1.618em .4045em 8.899em}.wy-menu-vertical li.toctree-l6.current>a{padding:.4045em 8.899em}.wy-menu-vertical li.toctree-l6.current li.toctree-l7>a{padding:.4045em 1.618em .4045em 10.517em}.wy-menu-vertical li.toctree-l7.current>a{padding:.4045em 10.517em}.wy-menu-vertical li.toctree-l7.current li.toctree-l8>a{padding:.4045em 1.618em .4045em 12.135em}.wy-menu-vertical li.toctree-l8.current>a{padding:.4045em 12.135em}.wy-menu-vertical li.toctree-l8.current li.toctree-l9>a{padding:.4045em 1.618em .4045em 13.753em}.wy-menu-vertical li.toctree-l9.current>a{padding:.4045em 13.753em}.wy-menu-vertical li.toctree-l9.current li.toctree-l10>a{padding:.4045em 1.618em .4045em 15.371em}.wy-menu-vertical li.toctree-l10.current>a{padding:.4045em 15.371em}.wy-menu-vertical li.toctree-l10.current li.toctree-l11>a{padding:.4045em 1.618em .4045em 16.989em}.wy-menu-vertical li.toctree-l2.current>a,.wy-menu-vertical li.toctree-l2.current li.toctree-l3>a{background:#c9c9c9}.wy-menu-vertical li.toctree-l2 button.toctree-expand{color:#a3a3a3}.wy-menu-vertical li.toctree-l3.current>a,.wy-menu-vertical li.toctree-l3.current li.toctree-l4>a{background:#bdbdbd}.wy-menu-vertical li.toctree-l3 button.toctree-expand{color:#969696}.wy-menu-vertical li.current ul{display:block}.wy-menu-vertical li ul{margin-bottom:0;display:none}.wy-menu-vertical li ul li a{margin-bottom:0;color:#d9d9d9;font-weight:400}.wy-menu-vertical a{line-height:18px;padding:.4045em 1.618em;display:block;position:relative;font-size:90%;color:#d9d9d9}.wy-menu-vertical a:hover{background-color:#4e4a4a;cursor:pointer}.wy-menu-vertical a:hover button.toctree-expand{color:#d9d9d9}.wy-menu-vertical a:active{background-color:#2980b9;cursor:pointer;color:#fff}.wy-menu-vertical a:active button.toctree-expand{color:#fff}.wy-side-nav-search{display:block;width:300px;padding:.809em;margin-bottom:.809em;z-index:200;background-color:#2980b9;text-align:center;color:#fcfcfc}.wy-side-nav-search input[type=text]{width:100%;border-radius:50px;padding:6px 12px;border-color:#2472a4}.wy-side-nav-search img{display:block;margin:auto auto .809em;height:45px;width:45px;background-color:#2980b9;padding:5px;border-radius:100%}.wy-side-nav-search .wy-dropdown>a,.wy-side-nav-search>a{color:#fcfcfc;font-size:100%;font-weight:700;display:inline-block;padding:4px 6px;margin-bottom:.809em;max-width:100%}.wy-side-nav-search .wy-dropdown>a:hover,.wy-side-nav-search>a:hover{background:hsla(0,0%,100%,.1)}.wy-side-nav-search .wy-dropdown>a img.logo,.wy-side-nav-search>a img.logo{display:block;margin:0 auto;height:auto;width:auto;border-radius:0;max-width:100%;background:transparent}.wy-side-nav-search .wy-dropdown>a.icon img.logo,.wy-side-nav-search>a.icon img.logo{margin-top:.85em}.wy-side-nav-search>div.version{margin-top:-.4045em;margin-bottom:.809em;font-weight:400;color:hsla(0,0%,100%,.3)}.wy-nav .wy-menu-vertical header{color:#2980b9}.wy-nav .wy-menu-vertical a{color:#b3b3b3}.wy-nav .wy-menu-vertical a:hover{background-color:#2980b9;color:#fff}[data-menu-wrap]{-webkit-transition:all .2s ease-in;-moz-transition:all .2s ease-in;transition:all .2s ease-in;position:absolute;opacity:1;width:100%;opacity:0}[data-menu-wrap].move-center{left:0;right:auto;opacity:1}[data-menu-wrap].move-left{right:auto;left:-100%;opacity:0}[data-menu-wrap].move-right{right:-100%;left:auto;opacity:0}.wy-body-for-nav{background:#fcfcfc}.wy-grid-for-nav{position:absolute;width:100%;height:100%}.wy-nav-side{position:fixed;top:0;bottom:0;left:0;padding-bottom:2em;width:300px;overflow-x:hidden;overflow-y:hidden;min-height:100%;color:#9b9b9b;background:#343131;z-index:200}.wy-side-scroll{width:320px;position:relative;overflow-x:hidden;overflow-y:scroll;height:100%}.wy-nav-top{display:none;background:#2980b9;color:#fff;padding:.4045em .809em;position:relative;line-height:50px;text-align:center;font-size:100%;*zoom:1}.wy-nav-top:after,.wy-nav-top:before{display:table;content:""}.wy-nav-top:after{clear:both}.wy-nav-top a{color:#fff;font-weight:700}.wy-nav-top img{margin-right:12px;height:45px;width:45px;background-color:#2980b9;padding:5px;border-radius:100%}.wy-nav-top i{font-size:30px;float:left;cursor:pointer;padding-top:inherit}.wy-nav-content-wrap{margin-left:300px;background:#fcfcfc;min-height:100%}.wy-nav-content{padding:1.618em 3.236em;height:100%;max-width:800px;margin:auto}.wy-body-mask{position:fixed;width:100%;height:100%;background:rgba(0,0,0,.2);display:none;z-index:499}.wy-body-mask.on{display:block}footer{color:grey}footer p{margin-bottom:12px}.rst-content footer span.commit tt,footer span.commit .rst-content tt,footer span.commit code{padding:0;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;font-size:1em;background:none;border:none;color:grey}.rst-footer-buttons{*zoom:1}.rst-footer-buttons:after,.rst-footer-buttons:before{width:100%;display:table;content:""}.rst-footer-buttons:after{clear:both}.rst-breadcrumbs-buttons{margin-top:12px;*zoom:1}.rst-breadcrumbs-buttons:after,.rst-breadcrumbs-buttons:before{display:table;content:""}.rst-breadcrumbs-buttons:after{clear:both}#search-results .search li{margin-bottom:24px;border-bottom:1px solid #e1e4e5;padding-bottom:24px}#search-results .search li:first-child{border-top:1px solid #e1e4e5;padding-top:24px}#search-results .search li a{font-size:120%;margin-bottom:12px;display:inline-block}#search-results .context{color:grey;font-size:90%}.genindextable li>ul{margin-left:24px}@media screen and (max-width:768px){.wy-body-for-nav{background:#fcfcfc}.wy-nav-top{display:block}.wy-nav-side{left:-300px}.wy-nav-side.shift{width:85%;left:0}.wy-menu.wy-menu-vertical,.wy-side-nav-search,.wy-side-scroll{width:auto}.wy-nav-content-wrap{margin-left:0}.wy-nav-content-wrap .wy-nav-content{padding:1.618em}.wy-nav-content-wrap.shift{position:fixed;min-width:100%;left:85%;top:0;height:100%;overflow:hidden}}@media screen and (min-width:1100px){.wy-nav-content-wrap{background:rgba(0,0,0,.05)}.wy-nav-content{margin:0;background:#fcfcfc}}@media print{.rst-versions,.wy-nav-side,footer{display:none}.wy-nav-content-wrap{margin-left:0}}.rst-versions{position:fixed;bottom:0;left:0;width:300px;color:#fcfcfc;background:#1f1d1d;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;z-index:400}.rst-versions a{color:#2980b9;text-decoration:none}.rst-versions .rst-badge-small{display:none}.rst-versions .rst-current-version{padding:12px;background-color:#272525;display:block;text-align:right;font-size:90%;cursor:pointer;color:#27ae60;*zoom:1}.rst-versions .rst-current-version:after,.rst-versions .rst-current-version:before{display:table;content:""}.rst-versions .rst-current-version:after{clear:both}.rst-content .code-block-caption .rst-versions .rst-current-version .headerlink,.rst-content .eqno .rst-versions .rst-current-version .headerlink,.rst-content .rst-versions .rst-current-version .admonition-title,.rst-content code.download .rst-versions .rst-current-version span:first-child,.rst-content dl dt .rst-versions .rst-current-version .headerlink,.rst-content h1 .rst-versions .rst-current-version .headerlink,.rst-content h2 .rst-versions .rst-current-version .headerlink,.rst-content h3 .rst-versions .rst-current-version .headerlink,.rst-content h4 .rst-versions .rst-current-version .headerlink,.rst-content h5 .rst-versions .rst-current-version .headerlink,.rst-content h6 .rst-versions .rst-current-version .headerlink,.rst-content p .rst-versions .rst-current-version .headerlink,.rst-content table>caption .rst-versions .rst-current-version .headerlink,.rst-content tt.download .rst-versions .rst-current-version span:first-child,.rst-versions .rst-current-version .fa,.rst-versions .rst-current-version .icon,.rst-versions .rst-current-version .rst-content .admonition-title,.rst-versions .rst-current-version .rst-content .code-block-caption .headerlink,.rst-versions .rst-current-version .rst-content .eqno .headerlink,.rst-versions .rst-current-version .rst-content code.download span:first-child,.rst-versions .rst-current-version .rst-content dl dt .headerlink,.rst-versions .rst-current-version .rst-content h1 .headerlink,.rst-versions .rst-current-version .rst-content h2 .headerlink,.rst-versions .rst-current-version .rst-content h3 .headerlink,.rst-versions .rst-current-version .rst-content h4 .headerlink,.rst-versions .rst-current-version .rst-content h5 .headerlink,.rst-versions .rst-current-version .rst-content h6 .headerlink,.rst-versions .rst-current-version .rst-content p .headerlink,.rst-versions .rst-current-version .rst-content table>caption .headerlink,.rst-versions .rst-current-version .rst-content tt.download span:first-child,.rst-versions .rst-current-version .wy-menu-vertical li button.toctree-expand,.wy-menu-vertical li .rst-versions .rst-current-version button.toctree-expand{color:#fcfcfc}.rst-versions .rst-current-version .fa-book,.rst-versions .rst-current-version .icon-book{float:left}.rst-versions .rst-current-version.rst-out-of-date{background-color:#e74c3c;color:#fff}.rst-versions .rst-current-version.rst-active-old-version{background-color:#f1c40f;color:#000}.rst-versions.shift-up{height:auto;max-height:100%;overflow-y:scroll}.rst-versions.shift-up .rst-other-versions{display:block}.rst-versions .rst-other-versions{font-size:90%;padding:12px;color:grey;display:none}.rst-versions .rst-other-versions hr{display:block;height:1px;border:0;margin:20px 0;padding:0;border-top:1px solid #413d3d}.rst-versions .rst-other-versions dd{display:inline-block;margin:0}.rst-versions .rst-other-versions dd a{display:inline-block;padding:6px;color:#fcfcfc}.rst-versions.rst-badge{width:auto;bottom:20px;right:20px;left:auto;border:none;max-width:300px;max-height:90%}.rst-versions.rst-badge .fa-book,.rst-versions.rst-badge .icon-book{float:none;line-height:30px}.rst-versions.rst-badge.shift-up .rst-current-version{text-align:right}.rst-versions.rst-badge.shift-up .rst-current-version .fa-book,.rst-versions.rst-badge.shift-up .rst-current-version .icon-book{float:left}.rst-versions.rst-badge>.rst-current-version{width:auto;height:30px;line-height:30px;padding:0 6px;display:block;text-align:center}@media screen and (max-width:768px){.rst-versions{width:85%;display:none}.rst-versions.shift{display:block}}.rst-content .toctree-wrapper>p.caption,.rst-content h1,.rst-content h2,.rst-content h3,.rst-content h4,.rst-content h5,.rst-content h6{margin-bottom:24px}.rst-content img{max-width:100%;height:auto}.rst-content div.figure,.rst-content figure{margin-bottom:24px}.rst-content div.figure .caption-text,.rst-content figure .caption-text{font-style:italic}.rst-content div.figure p:last-child.caption,.rst-content figure p:last-child.caption{margin-bottom:0}.rst-content div.figure.align-center,.rst-content figure.align-center{text-align:center}.rst-content .section>a>img,.rst-content .section>img,.rst-content section>a>img,.rst-content section>img{margin-bottom:24px}.rst-content abbr[title]{text-decoration:none}.rst-content.style-external-links a.reference.external:after{font-family:FontAwesome;content:"\f08e";color:#b3b3b3;vertical-align:super;font-size:60%;margin:0 .2em}.rst-content blockquote{margin-left:24px;line-height:24px;margin-bottom:24px}.rst-content pre.literal-block{white-space:pre;margin:0;padding:12px;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;display:block;overflow:auto}.rst-content div[class^=highlight],.rst-content pre.literal-block{border:1px solid #e1e4e5;overflow-x:auto;margin:1px 0 24px}.rst-content div[class^=highlight] div[class^=highlight],.rst-content pre.literal-block div[class^=highlight]{padding:0;border:none;margin:0}.rst-content div[class^=highlight] td.code{width:100%}.rst-content .linenodiv pre{border-right:1px solid #e6e9ea;margin:0;padding:12px;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;user-select:none;pointer-events:none}.rst-content div[class^=highlight] pre{white-space:pre;margin:0;padding:12px;display:block;overflow:auto}.rst-content div[class^=highlight] pre .hll{display:block;margin:0 -12px;padding:0 12px}.rst-content .linenodiv pre,.rst-content div[class^=highlight] pre,.rst-content pre.literal-block{font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;font-size:12px;line-height:1.4}.rst-content div.highlight .gp,.rst-content div.highlight span.linenos{user-select:none;pointer-events:none}.rst-content div.highlight span.linenos{display:inline-block;padding-left:0;padding-right:12px;margin-right:12px;border-right:1px solid #e6e9ea}.rst-content .code-block-caption{font-style:italic;font-size:85%;line-height:1;padding:1em 0;text-align:center}@media print{.rst-content .codeblock,.rst-content div[class^=highlight],.rst-content div[class^=highlight] pre{white-space:pre-wrap}}.rst-content .admonition,.rst-content .admonition-todo,.rst-content .attention,.rst-content .caution,.rst-content .danger,.rst-content .error,.rst-content .hint,.rst-content .important,.rst-content .note,.rst-content .seealso,.rst-content .tip,.rst-content .warning{clear:both}.rst-content .admonition-todo .last,.rst-content .admonition-todo>:last-child,.rst-content .admonition .last,.rst-content .admonition>:last-child,.rst-content .attention .last,.rst-content .attention>:last-child,.rst-content .caution .last,.rst-content .caution>:last-child,.rst-content .danger .last,.rst-content .danger>:last-child,.rst-content .error .last,.rst-content .error>:last-child,.rst-content .hint .last,.rst-content .hint>:last-child,.rst-content .important .last,.rst-content .important>:last-child,.rst-content .note .last,.rst-content .note>:last-child,.rst-content .seealso .last,.rst-content .seealso>:last-child,.rst-content .tip .last,.rst-content .tip>:last-child,.rst-content .warning .last,.rst-content .warning>:last-child{margin-bottom:0}.rst-content .admonition-title:before{margin-right:4px}.rst-content .admonition table{border-color:rgba(0,0,0,.1)}.rst-content .admonition table td,.rst-content .admonition table th{background:transparent!important;border-color:rgba(0,0,0,.1)!important}.rst-content .section ol.loweralpha,.rst-content .section ol.loweralpha>li,.rst-content .toctree-wrapper ol.loweralpha,.rst-content .toctree-wrapper ol.loweralpha>li,.rst-content section ol.loweralpha,.rst-content section ol.loweralpha>li{list-style:lower-alpha}.rst-content .section ol.upperalpha,.rst-content .section ol.upperalpha>li,.rst-content .toctree-wrapper ol.upperalpha,.rst-content .toctree-wrapper ol.upperalpha>li,.rst-content section ol.upperalpha,.rst-content section ol.upperalpha>li{list-style:upper-alpha}.rst-content .section ol li>*,.rst-content .section ul li>*,.rst-content .toctree-wrapper ol li>*,.rst-content .toctree-wrapper ul li>*,.rst-content section ol li>*,.rst-content section ul li>*{margin-top:12px;margin-bottom:12px}.rst-content .section ol li>:first-child,.rst-content .section ul li>:first-child,.rst-content .toctree-wrapper ol li>:first-child,.rst-content .toctree-wrapper ul li>:first-child,.rst-content section ol li>:first-child,.rst-content section ul li>:first-child{margin-top:0}.rst-content .section ol li>p,.rst-content .section ol li>p:last-child,.rst-content .section ul li>p,.rst-content .section ul li>p:last-child,.rst-content .toctree-wrapper ol li>p,.rst-content .toctree-wrapper ol li>p:last-child,.rst-content .toctree-wrapper ul li>p,.rst-content .toctree-wrapper ul li>p:last-child,.rst-content section ol li>p,.rst-content section ol li>p:last-child,.rst-content section ul li>p,.rst-content section ul li>p:last-child{margin-bottom:12px}.rst-content .section ol li>p:only-child,.rst-content .section ol li>p:only-child:last-child,.rst-content .section ul li>p:only-child,.rst-content .section ul li>p:only-child:last-child,.rst-content .toctree-wrapper ol li>p:only-child,.rst-content .toctree-wrapper ol li>p:only-child:last-child,.rst-content .toctree-wrapper ul li>p:only-child,.rst-content .toctree-wrapper ul li>p:only-child:last-child,.rst-content section ol li>p:only-child,.rst-content section ol li>p:only-child:last-child,.rst-content section ul li>p:only-child,.rst-content section ul li>p:only-child:last-child{margin-bottom:0}.rst-content .section ol li>ol,.rst-content .section ol li>ul,.rst-content .section ul li>ol,.rst-content .section ul li>ul,.rst-content .toctree-wrapper ol li>ol,.rst-content .toctree-wrapper ol li>ul,.rst-content .toctree-wrapper ul li>ol,.rst-content .toctree-wrapper ul li>ul,.rst-content section ol li>ol,.rst-content section ol li>ul,.rst-content section ul li>ol,.rst-content section ul li>ul{margin-bottom:12px}.rst-content .section ol.simple li>*,.rst-content .section ol.simple li ol,.rst-content .section ol.simple li ul,.rst-content .section ul.simple li>*,.rst-content .section ul.simple li ol,.rst-content .section ul.simple li ul,.rst-content .toctree-wrapper ol.simple li>*,.rst-content .toctree-wrapper ol.simple li ol,.rst-content .toctree-wrapper ol.simple li ul,.rst-content .toctree-wrapper ul.simple li>*,.rst-content .toctree-wrapper ul.simple li ol,.rst-content .toctree-wrapper ul.simple li ul,.rst-content section ol.simple li>*,.rst-content section ol.simple li ol,.rst-content section ol.simple li ul,.rst-content section ul.simple li>*,.rst-content section ul.simple li ol,.rst-content section ul.simple li ul{margin-top:0;margin-bottom:0}.rst-content .line-block{margin-left:0;margin-bottom:24px;line-height:24px}.rst-content .line-block .line-block{margin-left:24px;margin-bottom:0}.rst-content .topic-title{font-weight:700;margin-bottom:12px}.rst-content .toc-backref{color:#404040}.rst-content .align-right{float:right;margin:0 0 24px 24px}.rst-content .align-left{float:left;margin:0 24px 24px 0}.rst-content .align-center{margin:auto}.rst-content .align-center:not(table){display:block}.rst-content .code-block-caption .headerlink,.rst-content .eqno .headerlink,.rst-content .toctree-wrapper>p.caption .headerlink,.rst-content dl dt .headerlink,.rst-content h1 .headerlink,.rst-content h2 .headerlink,.rst-content h3 .headerlink,.rst-content h4 .headerlink,.rst-content h5 .headerlink,.rst-content h6 .headerlink,.rst-content p.caption .headerlink,.rst-content p .headerlink,.rst-content table>caption .headerlink{opacity:0;font-size:14px;font-family:FontAwesome;margin-left:.5em}.rst-content .code-block-caption .headerlink:focus,.rst-content .code-block-caption:hover .headerlink,.rst-content .eqno .headerlink:focus,.rst-content .eqno:hover .headerlink,.rst-content .toctree-wrapper>p.caption .headerlink:focus,.rst-content .toctree-wrapper>p.caption:hover .headerlink,.rst-content dl dt .headerlink:focus,.rst-content dl dt:hover .headerlink,.rst-content h1 .headerlink:focus,.rst-content h1:hover .headerlink,.rst-content h2 .headerlink:focus,.rst-content h2:hover .headerlink,.rst-content h3 .headerlink:focus,.rst-content h3:hover .headerlink,.rst-content h4 .headerlink:focus,.rst-content h4:hover .headerlink,.rst-content h5 .headerlink:focus,.rst-content h5:hover .headerlink,.rst-content h6 .headerlink:focus,.rst-content h6:hover .headerlink,.rst-content p.caption .headerlink:focus,.rst-content p.caption:hover .headerlink,.rst-content p .headerlink:focus,.rst-content p:hover .headerlink,.rst-content table>caption .headerlink:focus,.rst-content table>caption:hover .headerlink{opacity:1}.rst-content .btn:focus{outline:2px solid}.rst-content table>caption .headerlink:after{font-size:12px}.rst-content .centered{text-align:center}.rst-content .sidebar{float:right;width:40%;display:block;margin:0 0 24px 24px;padding:24px;background:#f3f6f6;border:1px solid #e1e4e5}.rst-content .sidebar dl,.rst-content .sidebar p,.rst-content .sidebar ul{font-size:90%}.rst-content .sidebar .last,.rst-content .sidebar>:last-child{margin-bottom:0}.rst-content .sidebar .sidebar-title{display:block;font-family:Roboto Slab,ff-tisa-web-pro,Georgia,Arial,sans-serif;font-weight:700;background:#e1e4e5;padding:6px 12px;margin:-24px -24px 24px;font-size:100%}.rst-content .highlighted{background:#f1c40f;box-shadow:0 0 0 2px #f1c40f;display:inline;font-weight:700}.rst-content .citation-reference,.rst-content .footnote-reference{vertical-align:baseline;position:relative;top:-.4em;line-height:0;font-size:90%}.rst-content .hlist{width:100%}.rst-content dl dt span.classifier:before{content:" : "}.rst-content dl dt span.classifier-delimiter{display:none!important}html.writer-html4 .rst-content table.docutils.citation,html.writer-html4 .rst-content table.docutils.footnote{background:none;border:none}html.writer-html4 .rst-content table.docutils.citation td,html.writer-html4 .rst-content table.docutils.citation tr,html.writer-html4 .rst-content table.docutils.footnote td,html.writer-html4 .rst-content table.docutils.footnote tr{border:none;background-color:transparent!important;white-space:normal}html.writer-html4 .rst-content table.docutils.citation td.label,html.writer-html4 .rst-content table.docutils.footnote td.label{padding-left:0;padding-right:0;vertical-align:top}html.writer-html5 .rst-content dl.field-list,html.writer-html5 .rst-content dl.footnote{display:grid;grid-template-columns:max-content auto}html.writer-html5 .rst-content dl.field-list>dt,html.writer-html5 .rst-content dl.footnote>dt{padding-left:1rem}html.writer-html5 .rst-content dl.field-list>dt:after,html.writer-html5 .rst-content dl.footnote>dt:after{content:":"}html.writer-html5 .rst-content dl.field-list>dd,html.writer-html5 .rst-content dl.field-list>dt,html.writer-html5 .rst-content dl.footnote>dd,html.writer-html5 .rst-content dl.footnote>dt{margin-bottom:0}html.writer-html5 .rst-content dl.footnote{font-size:.9rem}html.writer-html5 .rst-content dl.footnote>dt{margin:0 .5rem .5rem 0;line-height:1.2rem;word-break:break-all;font-weight:400}html.writer-html5 .rst-content dl.footnote>dt>span.brackets{margin-right:.5rem}html.writer-html5 .rst-content dl.footnote>dt>span.brackets:before{content:"["}html.writer-html5 .rst-content dl.footnote>dt>span.brackets:after{content:"]"}html.writer-html5 .rst-content dl.footnote>dt>span.fn-backref{font-style:italic}html.writer-html5 .rst-content dl.footnote>dd{margin:0 0 .5rem;line-height:1.2rem}html.writer-html5 .rst-content dl.footnote>dd p,html.writer-html5 .rst-content dl.option-list kbd{font-size:.9rem}.rst-content table.docutils.footnote,html.writer-html4 .rst-content table.docutils.citation,html.writer-html5 .rst-content dl.footnote{color:grey}.rst-content table.docutils.footnote code,.rst-content table.docutils.footnote tt,html.writer-html4 .rst-content table.docutils.citation code,html.writer-html4 .rst-content table.docutils.citation tt,html.writer-html5 .rst-content dl.footnote code,html.writer-html5 .rst-content dl.footnote tt{color:#555}.rst-content .wy-table-responsive.citation,.rst-content .wy-table-responsive.footnote{margin-bottom:0}.rst-content .wy-table-responsive.citation+:not(.citation),.rst-content .wy-table-responsive.footnote+:not(.footnote){margin-top:24px}.rst-content .wy-table-responsive.citation:last-child,.rst-content .wy-table-responsive.footnote:last-child{margin-bottom:24px}.rst-content table.docutils th{border-color:#e1e4e5}html.writer-html5 .rst-content table.docutils th{border:1px solid #e1e4e5}html.writer-html5 .rst-content table.docutils td>p,html.writer-html5 .rst-content table.docutils th>p{line-height:1rem;margin-bottom:0;font-size:.9rem}.rst-content table.docutils td .last,.rst-content table.docutils td .last>:last-child{margin-bottom:0}.rst-content table.field-list,.rst-content table.field-list td{border:none}.rst-content table.field-list td p{font-size:inherit;line-height:inherit}.rst-content table.field-list td>strong{display:inline-block}.rst-content table.field-list .field-name{padding-right:10px;text-align:left;white-space:nowrap}.rst-content table.field-list .field-body{text-align:left}.rst-content code,.rst-content tt{color:#000;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;padding:2px 5px}.rst-content code big,.rst-content code em,.rst-content tt big,.rst-content tt em{font-size:100%!important;line-height:normal}.rst-content code.literal,.rst-content tt.literal{color:#e74c3c;white-space:normal}.rst-content code.xref,.rst-content tt.xref,a .rst-content code,a .rst-content tt{font-weight:700;color:#404040}.rst-content kbd,.rst-content pre,.rst-content samp{font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace}.rst-content a code,.rst-content a tt{color:#2980b9}.rst-content dl{margin-bottom:24px}.rst-content dl dt{font-weight:700;margin-bottom:12px}.rst-content dl ol,.rst-content dl p,.rst-content dl table,.rst-content dl ul{margin-bottom:12px}.rst-content dl dd{margin:0 0 12px 24px;line-height:24px}html.writer-html4 .rst-content dl:not(.docutils),html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.glossary):not(.simple){margin-bottom:24px}html.writer-html4 .rst-content dl:not(.docutils)>dt,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.glossary):not(.simple)>dt{display:table;margin:6px 0;font-size:90%;line-height:normal;background:#e7f2fa;color:#2980b9;border-top:3px solid #6ab0de;padding:6px;position:relative}html.writer-html4 .rst-content dl:not(.docutils)>dt:before,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.glossary):not(.simple)>dt:before{color:#6ab0de}html.writer-html4 .rst-content dl:not(.docutils)>dt .headerlink,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.glossary):not(.simple)>dt .headerlink{color:#404040;font-size:100%!important}html.writer-html4 .rst-content dl:not(.docutils) dl:not(.field-list)>dt,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.glossary):not(.simple) dl:not(.field-list)>dt{margin-bottom:6px;border:none;border-left:3px solid #ccc;background:#f0f0f0;color:#555}html.writer-html4 .rst-content dl:not(.docutils) dl:not(.field-list)>dt .headerlink,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.glossary):not(.simple) dl:not(.field-list)>dt .headerlink{color:#404040;font-size:100%!important}html.writer-html4 .rst-content dl:not(.docutils)>dt:first-child,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.glossary):not(.simple)>dt:first-child{margin-top:0}html.writer-html4 .rst-content dl:not(.docutils) code.descclassname,html.writer-html4 .rst-content dl:not(.docutils) code.descname,html.writer-html4 .rst-content dl:not(.docutils) tt.descclassname,html.writer-html4 .rst-content dl:not(.docutils) tt.descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.glossary):not(.simple) code.descclassname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.glossary):not(.simple) code.descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.glossary):not(.simple) tt.descclassname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.glossary):not(.simple) tt.descname{background-color:transparent;border:none;padding:0;font-size:100%!important}html.writer-html4 .rst-content dl:not(.docutils) code.descname,html.writer-html4 .rst-content dl:not(.docutils) tt.descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.glossary):not(.simple) code.descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.glossary):not(.simple) tt.descname{font-weight:700}html.writer-html4 .rst-content dl:not(.docutils) .optional,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.glossary):not(.simple) .optional{display:inline-block;padding:0 4px;color:#000;font-weight:700}html.writer-html4 .rst-content dl:not(.docutils) .property,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.glossary):not(.simple) .property{display:inline-block;padding-right:8px;max-width:100%}html.writer-html4 .rst-content dl:not(.docutils) .k,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.glossary):not(.simple) .k{font-style:italic}html.writer-html4 .rst-content dl:not(.docutils) .descclassname,html.writer-html4 .rst-content dl:not(.docutils) .descname,html.writer-html4 .rst-content dl:not(.docutils) .sig-name,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.glossary):not(.simple) .descclassname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.glossary):not(.simple) .descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.glossary):not(.simple) .sig-name{font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;color:#000}.rst-content .viewcode-back,.rst-content .viewcode-link{display:inline-block;color:#27ae60;font-size:80%;padding-left:24px}.rst-content .viewcode-back{display:block;float:right}.rst-content p.rubric{margin-bottom:12px;font-weight:700}.rst-content code.download,.rst-content tt.download{background:inherit;padding:inherit;font-weight:400;font-family:inherit;font-size:inherit;color:inherit;border:inherit;white-space:inherit}.rst-content code.download span:first-child,.rst-content tt.download span:first-child{-webkit-font-smoothing:subpixel-antialiased}.rst-content code.download span:first-child:before,.rst-content tt.download span:first-child:before{margin-right:4px}.rst-content .guilabel{border:1px solid #7fbbe3;background:#e7f2fa;font-size:80%;font-weight:700;border-radius:4px;padding:2.4px 6px;margin:auto 2px}.rst-content .versionmodified{font-style:italic}@media screen and (max-width:480px){.rst-content .sidebar{width:100%}}span[id*=MathJax-Span]{color:#404040}.math{text-align:center}@font-face{font-family:Lato;src:url(fonts/lato-normal.woff2?bd03a2cc277bbbc338d464e679fe9942) format("woff2"),url(fonts/lato-normal.woff?27bd77b9162d388cb8d4c4217c7c5e2a) format("woff");font-weight:400;font-style:normal;font-display:block}@font-face{font-family:Lato;src:url(fonts/lato-bold.woff2?cccb897485813c7c256901dbca54ecf2) format("woff2"),url(fonts/lato-bold.woff?d878b6c29b10beca227e9eef4246111b) format("woff");font-weight:700;font-style:normal;font-display:block}@font-face{font-family:Lato;src:url(fonts/lato-bold-italic.woff2?0b6bb6725576b072c5d0b02ecdd1900d) format("woff2"),url(fonts/lato-bold-italic.woff?9c7e4e9eb485b4a121c760e61bc3707c) format("woff");font-weight:700;font-style:italic;font-display:block}@font-face{font-family:Lato;src:url(fonts/lato-normal-italic.woff2?4eb103b4d12be57cb1d040ed5e162e9d) format("woff2"),url(fonts/lato-normal-italic.woff?f28f2d6482446544ef1ea1ccc6dd5892) format("woff");font-weight:400;font-style:italic;font-display:block}@font-face{font-family:Roboto Slab;font-style:normal;font-weight:400;src:url(fonts/Roboto-Slab-Regular.woff2?7abf5b8d04d26a2cafea937019bca958) format("woff2"),url(fonts/Roboto-Slab-Regular.woff?c1be9284088d487c5e3ff0a10a92e58c) format("woff");font-display:block}@font-face{font-family:Roboto Slab;font-style:normal;font-weight:700;src:url(fonts/Roboto-Slab-Bold.woff2?9984f4a9bda09be08e83f2506954adbe) format("woff2"),url(fonts/Roboto-Slab-Bold.woff?bed5564a116b05148e3b3bea6fb1162a) format("woff");font-display:block}
\ No newline at end of file
+ */@font-face{font-family:FontAwesome;src:url(fonts/fontawesome-webfont.eot?674f50d287a8c48dc19ba404d20fe713);src:url(fonts/fontawesome-webfont.eot?674f50d287a8c48dc19ba404d20fe713?#iefix&v=4.7.0) format("embedded-opentype"),url(fonts/fontawesome-webfont.woff2?af7ae505a9eed503f8b8e6982036873e) format("woff2"),url(fonts/fontawesome-webfont.woff?fee66e712a8a08eef5805a46892932ad) format("woff"),url(fonts/fontawesome-webfont.ttf?b06871f281fee6b241d60582ae9369b9) format("truetype"),url(fonts/fontawesome-webfont.svg?912ec66d7572ff821749319396470bde#fontawesomeregular) format("svg");font-weight:400;font-style:normal}.fa,.icon,.rst-content .admonition-title,.rst-content .code-block-caption .headerlink,.rst-content .eqno .headerlink,.rst-content code.download span:first-child,.rst-content dl dt .headerlink,.rst-content h1 .headerlink,.rst-content h2 .headerlink,.rst-content h3 .headerlink,.rst-content h4 .headerlink,.rst-content h5 .headerlink,.rst-content h6 .headerlink,.rst-content p.caption .headerlink,.rst-content p .headerlink,.rst-content table>caption .headerlink,.rst-content tt.download span:first-child,.wy-menu-vertical li.current>a button.toctree-expand,.wy-menu-vertical li.on a button.toctree-expand,.wy-menu-vertical li button.toctree-expand{display:inline-block;font:normal normal normal 14px/1 FontAwesome;font-size:inherit;text-rendering:auto;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}.fa-lg{font-size:1.33333em;line-height:.75em;vertical-align:-15%}.fa-2x{font-size:2em}.fa-3x{font-size:3em}.fa-4x{font-size:4em}.fa-5x{font-size:5em}.fa-fw{width:1.28571em;text-align:center}.fa-ul{padding-left:0;margin-left:2.14286em;list-style-type:none}.fa-ul>li{position:relative}.fa-li{position:absolute;left:-2.14286em;width:2.14286em;top:.14286em;text-align:center}.fa-li.fa-lg{left:-1.85714em}.fa-border{padding:.2em .25em .15em;border:.08em solid #eee;border-radius:.1em}.fa-pull-left{float:left}.fa-pull-right{float:right}.fa-pull-left.icon,.fa.fa-pull-left,.rst-content .code-block-caption .fa-pull-left.headerlink,.rst-content .eqno .fa-pull-left.headerlink,.rst-content .fa-pull-left.admonition-title,.rst-content code.download span.fa-pull-left:first-child,.rst-content dl dt .fa-pull-left.headerlink,.rst-content h1 .fa-pull-left.headerlink,.rst-content h2 .fa-pull-left.headerlink,.rst-content h3 .fa-pull-left.headerlink,.rst-content h4 .fa-pull-left.headerlink,.rst-content h5 .fa-pull-left.headerlink,.rst-content h6 .fa-pull-left.headerlink,.rst-content p .fa-pull-left.headerlink,.rst-content table>caption .fa-pull-left.headerlink,.rst-content tt.download span.fa-pull-left:first-child,.wy-menu-vertical li.current>a button.fa-pull-left.toctree-expand,.wy-menu-vertical li.on a button.fa-pull-left.toctree-expand,.wy-menu-vertical li button.fa-pull-left.toctree-expand{margin-right:.3em}.fa-pull-right.icon,.fa.fa-pull-right,.rst-content .code-block-caption .fa-pull-right.headerlink,.rst-content .eqno .fa-pull-right.headerlink,.rst-content .fa-pull-right.admonition-title,.rst-content code.download span.fa-pull-right:first-child,.rst-content dl dt .fa-pull-right.headerlink,.rst-content h1 .fa-pull-right.headerlink,.rst-content h2 .fa-pull-right.headerlink,.rst-content h3 .fa-pull-right.headerlink,.rst-content h4 .fa-pull-right.headerlink,.rst-content h5 .fa-pull-right.headerlink,.rst-content h6 .fa-pull-right.headerlink,.rst-content p .fa-pull-right.headerlink,.rst-content table>caption .fa-pull-right.headerlink,.rst-content tt.download span.fa-pull-right:first-child,.wy-menu-vertical li.current>a button.fa-pull-right.toctree-expand,.wy-menu-vertical li.on a button.fa-pull-right.toctree-expand,.wy-menu-vertical li button.fa-pull-right.toctree-expand{margin-left:.3em}.pull-right{float:right}.pull-left{float:left}.fa.pull-left,.pull-left.icon,.rst-content .code-block-caption .pull-left.headerlink,.rst-content .eqno .pull-left.headerlink,.rst-content .pull-left.admonition-title,.rst-content code.download span.pull-left:first-child,.rst-content dl dt .pull-left.headerlink,.rst-content h1 .pull-left.headerlink,.rst-content h2 .pull-left.headerlink,.rst-content h3 .pull-left.headerlink,.rst-content h4 .pull-left.headerlink,.rst-content h5 .pull-left.headerlink,.rst-content h6 .pull-left.headerlink,.rst-content p .pull-left.headerlink,.rst-content table>caption .pull-left.headerlink,.rst-content tt.download span.pull-left:first-child,.wy-menu-vertical li.current>a button.pull-left.toctree-expand,.wy-menu-vertical li.on a button.pull-left.toctree-expand,.wy-menu-vertical li button.pull-left.toctree-expand{margin-right:.3em}.fa.pull-right,.pull-right.icon,.rst-content .code-block-caption .pull-right.headerlink,.rst-content .eqno .pull-right.headerlink,.rst-content .pull-right.admonition-title,.rst-content code.download span.pull-right:first-child,.rst-content dl dt .pull-right.headerlink,.rst-content h1 .pull-right.headerlink,.rst-content h2 .pull-right.headerlink,.rst-content h3 .pull-right.headerlink,.rst-content h4 .pull-right.headerlink,.rst-content h5 .pull-right.headerlink,.rst-content h6 .pull-right.headerlink,.rst-content p .pull-right.headerlink,.rst-content table>caption .pull-right.headerlink,.rst-content tt.download span.pull-right:first-child,.wy-menu-vertical li.current>a button.pull-right.toctree-expand,.wy-menu-vertical li.on a button.pull-right.toctree-expand,.wy-menu-vertical li button.pull-right.toctree-expand{margin-left:.3em}.fa-spin{-webkit-animation:fa-spin 2s linear infinite;animation:fa-spin 2s linear infinite}.fa-pulse{-webkit-animation:fa-spin 1s steps(8) infinite;animation:fa-spin 1s steps(8) infinite}@-webkit-keyframes fa-spin{0%{-webkit-transform:rotate(0deg);transform:rotate(0deg)}to{-webkit-transform:rotate(359deg);transform:rotate(359deg)}}@keyframes fa-spin{0%{-webkit-transform:rotate(0deg);transform:rotate(0deg)}to{-webkit-transform:rotate(359deg);transform:rotate(359deg)}}.fa-rotate-90{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=1)";-webkit-transform:rotate(90deg);-ms-transform:rotate(90deg);transform:rotate(90deg)}.fa-rotate-180{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=2)";-webkit-transform:rotate(180deg);-ms-transform:rotate(180deg);transform:rotate(180deg)}.fa-rotate-270{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=3)";-webkit-transform:rotate(270deg);-ms-transform:rotate(270deg);transform:rotate(270deg)}.fa-flip-horizontal{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=0, mirror=1)";-webkit-transform:scaleX(-1);-ms-transform:scaleX(-1);transform:scaleX(-1)}.fa-flip-vertical{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1)";-webkit-transform:scaleY(-1);-ms-transform:scaleY(-1);transform:scaleY(-1)}:root .fa-flip-horizontal,:root .fa-flip-vertical,:root .fa-rotate-90,:root .fa-rotate-180,:root .fa-rotate-270{filter:none}.fa-stack{position:relative;display:inline-block;width:2em;height:2em;line-height:2em;vertical-align:middle}.fa-stack-1x,.fa-stack-2x{position:absolute;left:0;width:100%;text-align:center}.fa-stack-1x{line-height:inherit}.fa-stack-2x{font-size:2em}.fa-inverse{color:#fff}.fa-glass:before{content:""}.fa-music:before{content:""}.fa-search:before,.icon-search:before{content:""}.fa-envelope-o:before{content:""}.fa-heart:before{content:""}.fa-star:before{content:""}.fa-star-o:before{content:""}.fa-user:before{content:""}.fa-film:before{content:""}.fa-th-large:before{content:""}.fa-th:before{content:""}.fa-th-list:before{content:""}.fa-check:before{content:""}.fa-close:before,.fa-remove:before,.fa-times:before{content:""}.fa-search-plus:before{content:""}.fa-search-minus:before{content:""}.fa-power-off:before{content:""}.fa-signal:before{content:""}.fa-cog:before,.fa-gear:before{content:""}.fa-trash-o:before{content:""}.fa-home:before,.icon-home:before{content:""}.fa-file-o:before{content:""}.fa-clock-o:before{content:""}.fa-road:before{content:""}.fa-download:before,.rst-content code.download span:first-child:before,.rst-content tt.download span:first-child:before{content:""}.fa-arrow-circle-o-down:before{content:""}.fa-arrow-circle-o-up:before{content:""}.fa-inbox:before{content:""}.fa-play-circle-o:before{content:""}.fa-repeat:before,.fa-rotate-right:before{content:""}.fa-refresh:before{content:""}.fa-list-alt:before{content:""}.fa-lock:before{content:""}.fa-flag:before{content:""}.fa-headphones:before{content:""}.fa-volume-off:before{content:""}.fa-volume-down:before{content:""}.fa-volume-up:before{content:""}.fa-qrcode:before{content:""}.fa-barcode:before{content:""}.fa-tag:before{content:""}.fa-tags:before{content:""}.fa-book:before,.icon-book:before{content:""}.fa-bookmark:before{content:""}.fa-print:before{content:""}.fa-camera:before{content:""}.fa-font:before{content:""}.fa-bold:before{content:""}.fa-italic:before{content:""}.fa-text-height:before{content:""}.fa-text-width:before{content:""}.fa-align-left:before{content:""}.fa-align-center:before{content:""}.fa-align-right:before{content:""}.fa-align-justify:before{content:""}.fa-list:before{content:""}.fa-dedent:before,.fa-outdent:before{content:""}.fa-indent:before{content:""}.fa-video-camera:before{content:""}.fa-image:before,.fa-photo:before,.fa-picture-o:before{content:""}.fa-pencil:before{content:""}.fa-map-marker:before{content:""}.fa-adjust:before{content:""}.fa-tint:before{content:""}.fa-edit:before,.fa-pencil-square-o:before{content:""}.fa-share-square-o:before{content:""}.fa-check-square-o:before{content:""}.fa-arrows:before{content:""}.fa-step-backward:before{content:""}.fa-fast-backward:before{content:""}.fa-backward:before{content:""}.fa-play:before{content:""}.fa-pause:before{content:""}.fa-stop:before{content:""}.fa-forward:before{content:""}.fa-fast-forward:before{content:""}.fa-step-forward:before{content:""}.fa-eject:before{content:""}.fa-chevron-left:before{content:""}.fa-chevron-right:before{content:""}.fa-plus-circle:before{content:""}.fa-minus-circle:before{content:""}.fa-times-circle:before,.wy-inline-validate.wy-inline-validate-danger .wy-input-context:before{content:""}.fa-check-circle:before,.wy-inline-validate.wy-inline-validate-success .wy-input-context:before{content:""}.fa-question-circle:before{content:""}.fa-info-circle:before{content:""}.fa-crosshairs:before{content:""}.fa-times-circle-o:before{content:""}.fa-check-circle-o:before{content:""}.fa-ban:before{content:""}.fa-arrow-left:before{content:""}.fa-arrow-right:before{content:""}.fa-arrow-up:before{content:""}.fa-arrow-down:before{content:""}.fa-mail-forward:before,.fa-share:before{content:""}.fa-expand:before{content:""}.fa-compress:before{content:""}.fa-plus:before{content:""}.fa-minus:before{content:""}.fa-asterisk:before{content:""}.fa-exclamation-circle:before,.rst-content .admonition-title:before,.wy-inline-validate.wy-inline-validate-info .wy-input-context:before,.wy-inline-validate.wy-inline-validate-warning .wy-input-context:before{content:""}.fa-gift:before{content:""}.fa-leaf:before{content:""}.fa-fire:before,.icon-fire:before{content:""}.fa-eye:before{content:""}.fa-eye-slash:before{content:""}.fa-exclamation-triangle:before,.fa-warning:before{content:""}.fa-plane:before{content:""}.fa-calendar:before{content:""}.fa-random:before{content:""}.fa-comment:before{content:""}.fa-magnet:before{content:""}.fa-chevron-up:before{content:""}.fa-chevron-down:before{content:""}.fa-retweet:before{content:""}.fa-shopping-cart:before{content:""}.fa-folder:before{content:""}.fa-folder-open:before{content:""}.fa-arrows-v:before{content:""}.fa-arrows-h:before{content:""}.fa-bar-chart-o:before,.fa-bar-chart:before{content:""}.fa-twitter-square:before{content:""}.fa-facebook-square:before{content:""}.fa-camera-retro:before{content:""}.fa-key:before{content:""}.fa-cogs:before,.fa-gears:before{content:""}.fa-comments:before{content:""}.fa-thumbs-o-up:before{content:""}.fa-thumbs-o-down:before{content:""}.fa-star-half:before{content:""}.fa-heart-o:before{content:""}.fa-sign-out:before{content:""}.fa-linkedin-square:before{content:""}.fa-thumb-tack:before{content:""}.fa-external-link:before{content:""}.fa-sign-in:before{content:""}.fa-trophy:before{content:""}.fa-github-square:before{content:""}.fa-upload:before{content:""}.fa-lemon-o:before{content:""}.fa-phone:before{content:""}.fa-square-o:before{content:""}.fa-bookmark-o:before{content:""}.fa-phone-square:before{content:""}.fa-twitter:before{content:""}.fa-facebook-f:before,.fa-facebook:before{content:""}.fa-github:before,.icon-github:before{content:""}.fa-unlock:before{content:""}.fa-credit-card:before{content:""}.fa-feed:before,.fa-rss:before{content:""}.fa-hdd-o:before{content:""}.fa-bullhorn:before{content:""}.fa-bell:before{content:""}.fa-certificate:before{content:""}.fa-hand-o-right:before{content:""}.fa-hand-o-left:before{content:""}.fa-hand-o-up:before{content:""}.fa-hand-o-down:before{content:""}.fa-arrow-circle-left:before,.icon-circle-arrow-left:before{content:""}.fa-arrow-circle-right:before,.icon-circle-arrow-right:before{content:""}.fa-arrow-circle-up:before{content:""}.fa-arrow-circle-down:before{content:""}.fa-globe:before{content:""}.fa-wrench:before{content:""}.fa-tasks:before{content:""}.fa-filter:before{content:""}.fa-briefcase:before{content:""}.fa-arrows-alt:before{content:""}.fa-group:before,.fa-users:before{content:""}.fa-chain:before,.fa-link:before,.icon-link:before{content:""}.fa-cloud:before{content:""}.fa-flask:before{content:""}.fa-cut:before,.fa-scissors:before{content:""}.fa-copy:before,.fa-files-o:before{content:""}.fa-paperclip:before{content:""}.fa-floppy-o:before,.fa-save:before{content:""}.fa-square:before{content:""}.fa-bars:before,.fa-navicon:before,.fa-reorder:before{content:""}.fa-list-ul:before{content:""}.fa-list-ol:before{content:""}.fa-strikethrough:before{content:""}.fa-underline:before{content:""}.fa-table:before{content:""}.fa-magic:before{content:""}.fa-truck:before{content:""}.fa-pinterest:before{content:""}.fa-pinterest-square:before{content:""}.fa-google-plus-square:before{content:""}.fa-google-plus:before{content:""}.fa-money:before{content:""}.fa-caret-down:before,.icon-caret-down:before,.wy-dropdown .caret:before{content:""}.fa-caret-up:before{content:""}.fa-caret-left:before{content:""}.fa-caret-right:before{content:""}.fa-columns:before{content:""}.fa-sort:before,.fa-unsorted:before{content:""}.fa-sort-desc:before,.fa-sort-down:before{content:""}.fa-sort-asc:before,.fa-sort-up:before{content:""}.fa-envelope:before{content:""}.fa-linkedin:before{content:""}.fa-rotate-left:before,.fa-undo:before{content:""}.fa-gavel:before,.fa-legal:before{content:""}.fa-dashboard:before,.fa-tachometer:before{content:""}.fa-comment-o:before{content:""}.fa-comments-o:before{content:""}.fa-bolt:before,.fa-flash:before{content:""}.fa-sitemap:before{content:""}.fa-umbrella:before{content:""}.fa-clipboard:before,.fa-paste:before{content:""}.fa-lightbulb-o:before{content:""}.fa-exchange:before{content:""}.fa-cloud-download:before{content:""}.fa-cloud-upload:before{content:""}.fa-user-md:before{content:""}.fa-stethoscope:before{content:""}.fa-suitcase:before{content:""}.fa-bell-o:before{content:""}.fa-coffee:before{content:""}.fa-cutlery:before{content:""}.fa-file-text-o:before{content:""}.fa-building-o:before{content:""}.fa-hospital-o:before{content:""}.fa-ambulance:before{content:""}.fa-medkit:before{content:""}.fa-fighter-jet:before{content:""}.fa-beer:before{content:""}.fa-h-square:before{content:""}.fa-plus-square:before{content:""}.fa-angle-double-left:before{content:""}.fa-angle-double-right:before{content:""}.fa-angle-double-up:before{content:""}.fa-angle-double-down:before{content:""}.fa-angle-left:before{content:""}.fa-angle-right:before{content:""}.fa-angle-up:before{content:""}.fa-angle-down:before{content:""}.fa-desktop:before{content:""}.fa-laptop:before{content:""}.fa-tablet:before{content:""}.fa-mobile-phone:before,.fa-mobile:before{content:""}.fa-circle-o:before{content:""}.fa-quote-left:before{content:""}.fa-quote-right:before{content:""}.fa-spinner:before{content:""}.fa-circle:before{content:""}.fa-mail-reply:before,.fa-reply:before{content:""}.fa-github-alt:before{content:""}.fa-folder-o:before{content:""}.fa-folder-open-o:before{content:""}.fa-smile-o:before{content:""}.fa-frown-o:before{content:""}.fa-meh-o:before{content:""}.fa-gamepad:before{content:""}.fa-keyboard-o:before{content:""}.fa-flag-o:before{content:""}.fa-flag-checkered:before{content:""}.fa-terminal:before{content:""}.fa-code:before{content:""}.fa-mail-reply-all:before,.fa-reply-all:before{content:""}.fa-star-half-empty:before,.fa-star-half-full:before,.fa-star-half-o:before{content:""}.fa-location-arrow:before{content:""}.fa-crop:before{content:""}.fa-code-fork:before{content:""}.fa-chain-broken:before,.fa-unlink:before{content:""}.fa-question:before{content:""}.fa-info:before{content:""}.fa-exclamation:before{content:""}.fa-superscript:before{content:""}.fa-subscript:before{content:""}.fa-eraser:before{content:""}.fa-puzzle-piece:before{content:""}.fa-microphone:before{content:""}.fa-microphone-slash:before{content:""}.fa-shield:before{content:""}.fa-calendar-o:before{content:""}.fa-fire-extinguisher:before{content:""}.fa-rocket:before{content:""}.fa-maxcdn:before{content:""}.fa-chevron-circle-left:before{content:""}.fa-chevron-circle-right:before{content:""}.fa-chevron-circle-up:before{content:""}.fa-chevron-circle-down:before{content:""}.fa-html5:before{content:""}.fa-css3:before{content:""}.fa-anchor:before{content:""}.fa-unlock-alt:before{content:""}.fa-bullseye:before{content:""}.fa-ellipsis-h:before{content:""}.fa-ellipsis-v:before{content:""}.fa-rss-square:before{content:""}.fa-play-circle:before{content:""}.fa-ticket:before{content:""}.fa-minus-square:before{content:""}.fa-minus-square-o:before,.wy-menu-vertical li.current>a button.toctree-expand:before,.wy-menu-vertical li.on a button.toctree-expand:before{content:""}.fa-level-up:before{content:""}.fa-level-down:before{content:""}.fa-check-square:before{content:""}.fa-pencil-square:before{content:""}.fa-external-link-square:before{content:""}.fa-share-square:before{content:""}.fa-compass:before{content:""}.fa-caret-square-o-down:before,.fa-toggle-down:before{content:""}.fa-caret-square-o-up:before,.fa-toggle-up:before{content:""}.fa-caret-square-o-right:before,.fa-toggle-right:before{content:""}.fa-eur:before,.fa-euro:before{content:""}.fa-gbp:before{content:""}.fa-dollar:before,.fa-usd:before{content:""}.fa-inr:before,.fa-rupee:before{content:""}.fa-cny:before,.fa-jpy:before,.fa-rmb:before,.fa-yen:before{content:""}.fa-rouble:before,.fa-rub:before,.fa-ruble:before{content:""}.fa-krw:before,.fa-won:before{content:""}.fa-bitcoin:before,.fa-btc:before{content:""}.fa-file:before{content:""}.fa-file-text:before{content:""}.fa-sort-alpha-asc:before{content:""}.fa-sort-alpha-desc:before{content:""}.fa-sort-amount-asc:before{content:""}.fa-sort-amount-desc:before{content:""}.fa-sort-numeric-asc:before{content:""}.fa-sort-numeric-desc:before{content:""}.fa-thumbs-up:before{content:""}.fa-thumbs-down:before{content:""}.fa-youtube-square:before{content:""}.fa-youtube:before{content:""}.fa-xing:before{content:""}.fa-xing-square:before{content:""}.fa-youtube-play:before{content:""}.fa-dropbox:before{content:""}.fa-stack-overflow:before{content:""}.fa-instagram:before{content:""}.fa-flickr:before{content:""}.fa-adn:before{content:""}.fa-bitbucket:before,.icon-bitbucket:before{content:""}.fa-bitbucket-square:before{content:""}.fa-tumblr:before{content:""}.fa-tumblr-square:before{content:""}.fa-long-arrow-down:before{content:""}.fa-long-arrow-up:before{content:""}.fa-long-arrow-left:before{content:""}.fa-long-arrow-right:before{content:""}.fa-apple:before{content:""}.fa-windows:before{content:""}.fa-android:before{content:""}.fa-linux:before{content:""}.fa-dribbble:before{content:""}.fa-skype:before{content:""}.fa-foursquare:before{content:""}.fa-trello:before{content:""}.fa-female:before{content:""}.fa-male:before{content:""}.fa-gittip:before,.fa-gratipay:before{content:""}.fa-sun-o:before{content:""}.fa-moon-o:before{content:""}.fa-archive:before{content:""}.fa-bug:before{content:""}.fa-vk:before{content:""}.fa-weibo:before{content:""}.fa-renren:before{content:""}.fa-pagelines:before{content:""}.fa-stack-exchange:before{content:""}.fa-arrow-circle-o-right:before{content:""}.fa-arrow-circle-o-left:before{content:""}.fa-caret-square-o-left:before,.fa-toggle-left:before{content:""}.fa-dot-circle-o:before{content:""}.fa-wheelchair:before{content:""}.fa-vimeo-square:before{content:""}.fa-try:before,.fa-turkish-lira:before{content:""}.fa-plus-square-o:before,.wy-menu-vertical li button.toctree-expand:before{content:""}.fa-space-shuttle:before{content:""}.fa-slack:before{content:""}.fa-envelope-square:before{content:""}.fa-wordpress:before{content:""}.fa-openid:before{content:""}.fa-bank:before,.fa-institution:before,.fa-university:before{content:""}.fa-graduation-cap:before,.fa-mortar-board:before{content:""}.fa-yahoo:before{content:""}.fa-google:before{content:""}.fa-reddit:before{content:""}.fa-reddit-square:before{content:""}.fa-stumbleupon-circle:before{content:""}.fa-stumbleupon:before{content:""}.fa-delicious:before{content:""}.fa-digg:before{content:""}.fa-pied-piper-pp:before{content:""}.fa-pied-piper-alt:before{content:""}.fa-drupal:before{content:""}.fa-joomla:before{content:""}.fa-language:before{content:""}.fa-fax:before{content:""}.fa-building:before{content:""}.fa-child:before{content:""}.fa-paw:before{content:""}.fa-spoon:before{content:""}.fa-cube:before{content:""}.fa-cubes:before{content:""}.fa-behance:before{content:""}.fa-behance-square:before{content:""}.fa-steam:before{content:""}.fa-steam-square:before{content:""}.fa-recycle:before{content:""}.fa-automobile:before,.fa-car:before{content:""}.fa-cab:before,.fa-taxi:before{content:""}.fa-tree:before{content:""}.fa-spotify:before{content:""}.fa-deviantart:before{content:""}.fa-soundcloud:before{content:""}.fa-database:before{content:""}.fa-file-pdf-o:before{content:""}.fa-file-word-o:before{content:""}.fa-file-excel-o:before{content:""}.fa-file-powerpoint-o:before{content:""}.fa-file-image-o:before,.fa-file-photo-o:before,.fa-file-picture-o:before{content:""}.fa-file-archive-o:before,.fa-file-zip-o:before{content:""}.fa-file-audio-o:before,.fa-file-sound-o:before{content:""}.fa-file-movie-o:before,.fa-file-video-o:before{content:""}.fa-file-code-o:before{content:""}.fa-vine:before{content:""}.fa-codepen:before{content:""}.fa-jsfiddle:before{content:""}.fa-life-bouy:before,.fa-life-buoy:before,.fa-life-ring:before,.fa-life-saver:before,.fa-support:before{content:""}.fa-circle-o-notch:before{content:""}.fa-ra:before,.fa-rebel:before,.fa-resistance:before{content:""}.fa-empire:before,.fa-ge:before{content:""}.fa-git-square:before{content:""}.fa-git:before{content:""}.fa-hacker-news:before,.fa-y-combinator-square:before,.fa-yc-square:before{content:""}.fa-tencent-weibo:before{content:""}.fa-qq:before{content:""}.fa-wechat:before,.fa-weixin:before{content:""}.fa-paper-plane:before,.fa-send:before{content:""}.fa-paper-plane-o:before,.fa-send-o:before{content:""}.fa-history:before{content:""}.fa-circle-thin:before{content:""}.fa-header:before{content:""}.fa-paragraph:before{content:""}.fa-sliders:before{content:""}.fa-share-alt:before{content:""}.fa-share-alt-square:before{content:""}.fa-bomb:before{content:""}.fa-futbol-o:before,.fa-soccer-ball-o:before{content:""}.fa-tty:before{content:""}.fa-binoculars:before{content:""}.fa-plug:before{content:""}.fa-slideshare:before{content:""}.fa-twitch:before{content:""}.fa-yelp:before{content:""}.fa-newspaper-o:before{content:""}.fa-wifi:before{content:""}.fa-calculator:before{content:""}.fa-paypal:before{content:""}.fa-google-wallet:before{content:""}.fa-cc-visa:before{content:""}.fa-cc-mastercard:before{content:""}.fa-cc-discover:before{content:""}.fa-cc-amex:before{content:""}.fa-cc-paypal:before{content:""}.fa-cc-stripe:before{content:""}.fa-bell-slash:before{content:""}.fa-bell-slash-o:before{content:""}.fa-trash:before{content:""}.fa-copyright:before{content:""}.fa-at:before{content:""}.fa-eyedropper:before{content:""}.fa-paint-brush:before{content:""}.fa-birthday-cake:before{content:""}.fa-area-chart:before{content:""}.fa-pie-chart:before{content:""}.fa-line-chart:before{content:""}.fa-lastfm:before{content:""}.fa-lastfm-square:before{content:""}.fa-toggle-off:before{content:""}.fa-toggle-on:before{content:""}.fa-bicycle:before{content:""}.fa-bus:before{content:""}.fa-ioxhost:before{content:""}.fa-angellist:before{content:""}.fa-cc:before{content:""}.fa-ils:before,.fa-shekel:before,.fa-sheqel:before{content:""}.fa-meanpath:before{content:""}.fa-buysellads:before{content:""}.fa-connectdevelop:before{content:""}.fa-dashcube:before{content:""}.fa-forumbee:before{content:""}.fa-leanpub:before{content:""}.fa-sellsy:before{content:""}.fa-shirtsinbulk:before{content:""}.fa-simplybuilt:before{content:""}.fa-skyatlas:before{content:""}.fa-cart-plus:before{content:""}.fa-cart-arrow-down:before{content:""}.fa-diamond:before{content:""}.fa-ship:before{content:""}.fa-user-secret:before{content:""}.fa-motorcycle:before{content:""}.fa-street-view:before{content:""}.fa-heartbeat:before{content:""}.fa-venus:before{content:""}.fa-mars:before{content:""}.fa-mercury:before{content:""}.fa-intersex:before,.fa-transgender:before{content:""}.fa-transgender-alt:before{content:""}.fa-venus-double:before{content:""}.fa-mars-double:before{content:""}.fa-venus-mars:before{content:""}.fa-mars-stroke:before{content:""}.fa-mars-stroke-v:before{content:""}.fa-mars-stroke-h:before{content:""}.fa-neuter:before{content:""}.fa-genderless:before{content:""}.fa-facebook-official:before{content:""}.fa-pinterest-p:before{content:""}.fa-whatsapp:before{content:""}.fa-server:before{content:""}.fa-user-plus:before{content:""}.fa-user-times:before{content:""}.fa-bed:before,.fa-hotel:before{content:""}.fa-viacoin:before{content:""}.fa-train:before{content:""}.fa-subway:before{content:""}.fa-medium:before{content:""}.fa-y-combinator:before,.fa-yc:before{content:""}.fa-optin-monster:before{content:""}.fa-opencart:before{content:""}.fa-expeditedssl:before{content:""}.fa-battery-4:before,.fa-battery-full:before,.fa-battery:before{content:""}.fa-battery-3:before,.fa-battery-three-quarters:before{content:""}.fa-battery-2:before,.fa-battery-half:before{content:""}.fa-battery-1:before,.fa-battery-quarter:before{content:""}.fa-battery-0:before,.fa-battery-empty:before{content:""}.fa-mouse-pointer:before{content:""}.fa-i-cursor:before{content:""}.fa-object-group:before{content:""}.fa-object-ungroup:before{content:""}.fa-sticky-note:before{content:""}.fa-sticky-note-o:before{content:""}.fa-cc-jcb:before{content:""}.fa-cc-diners-club:before{content:""}.fa-clone:before{content:""}.fa-balance-scale:before{content:""}.fa-hourglass-o:before{content:""}.fa-hourglass-1:before,.fa-hourglass-start:before{content:""}.fa-hourglass-2:before,.fa-hourglass-half:before{content:""}.fa-hourglass-3:before,.fa-hourglass-end:before{content:""}.fa-hourglass:before{content:""}.fa-hand-grab-o:before,.fa-hand-rock-o:before{content:""}.fa-hand-paper-o:before,.fa-hand-stop-o:before{content:""}.fa-hand-scissors-o:before{content:""}.fa-hand-lizard-o:before{content:""}.fa-hand-spock-o:before{content:""}.fa-hand-pointer-o:before{content:""}.fa-hand-peace-o:before{content:""}.fa-trademark:before{content:""}.fa-registered:before{content:""}.fa-creative-commons:before{content:""}.fa-gg:before{content:""}.fa-gg-circle:before{content:""}.fa-tripadvisor:before{content:""}.fa-odnoklassniki:before{content:""}.fa-odnoklassniki-square:before{content:""}.fa-get-pocket:before{content:""}.fa-wikipedia-w:before{content:""}.fa-safari:before{content:""}.fa-chrome:before{content:""}.fa-firefox:before{content:""}.fa-opera:before{content:""}.fa-internet-explorer:before{content:""}.fa-television:before,.fa-tv:before{content:""}.fa-contao:before{content:""}.fa-500px:before{content:""}.fa-amazon:before{content:""}.fa-calendar-plus-o:before{content:""}.fa-calendar-minus-o:before{content:""}.fa-calendar-times-o:before{content:""}.fa-calendar-check-o:before{content:""}.fa-industry:before{content:""}.fa-map-pin:before{content:""}.fa-map-signs:before{content:""}.fa-map-o:before{content:""}.fa-map:before{content:""}.fa-commenting:before{content:""}.fa-commenting-o:before{content:""}.fa-houzz:before{content:""}.fa-vimeo:before{content:""}.fa-black-tie:before{content:""}.fa-fonticons:before{content:""}.fa-reddit-alien:before{content:""}.fa-edge:before{content:""}.fa-credit-card-alt:before{content:""}.fa-codiepie:before{content:""}.fa-modx:before{content:""}.fa-fort-awesome:before{content:""}.fa-usb:before{content:""}.fa-product-hunt:before{content:""}.fa-mixcloud:before{content:""}.fa-scribd:before{content:""}.fa-pause-circle:before{content:""}.fa-pause-circle-o:before{content:""}.fa-stop-circle:before{content:""}.fa-stop-circle-o:before{content:""}.fa-shopping-bag:before{content:""}.fa-shopping-basket:before{content:""}.fa-hashtag:before{content:""}.fa-bluetooth:before{content:""}.fa-bluetooth-b:before{content:""}.fa-percent:before{content:""}.fa-gitlab:before,.icon-gitlab:before{content:""}.fa-wpbeginner:before{content:""}.fa-wpforms:before{content:""}.fa-envira:before{content:""}.fa-universal-access:before{content:""}.fa-wheelchair-alt:before{content:""}.fa-question-circle-o:before{content:""}.fa-blind:before{content:""}.fa-audio-description:before{content:""}.fa-volume-control-phone:before{content:""}.fa-braille:before{content:""}.fa-assistive-listening-systems:before{content:""}.fa-american-sign-language-interpreting:before,.fa-asl-interpreting:before{content:""}.fa-deaf:before,.fa-deafness:before,.fa-hard-of-hearing:before{content:""}.fa-glide:before{content:""}.fa-glide-g:before{content:""}.fa-sign-language:before,.fa-signing:before{content:""}.fa-low-vision:before{content:""}.fa-viadeo:before{content:""}.fa-viadeo-square:before{content:""}.fa-snapchat:before{content:""}.fa-snapchat-ghost:before{content:""}.fa-snapchat-square:before{content:""}.fa-pied-piper:before{content:""}.fa-first-order:before{content:""}.fa-yoast:before{content:""}.fa-themeisle:before{content:""}.fa-google-plus-circle:before,.fa-google-plus-official:before{content:""}.fa-fa:before,.fa-font-awesome:before{content:""}.fa-handshake-o:before{content:""}.fa-envelope-open:before{content:""}.fa-envelope-open-o:before{content:""}.fa-linode:before{content:""}.fa-address-book:before{content:""}.fa-address-book-o:before{content:""}.fa-address-card:before,.fa-vcard:before{content:""}.fa-address-card-o:before,.fa-vcard-o:before{content:""}.fa-user-circle:before{content:""}.fa-user-circle-o:before{content:""}.fa-user-o:before{content:""}.fa-id-badge:before{content:""}.fa-drivers-license:before,.fa-id-card:before{content:""}.fa-drivers-license-o:before,.fa-id-card-o:before{content:""}.fa-quora:before{content:""}.fa-free-code-camp:before{content:""}.fa-telegram:before{content:""}.fa-thermometer-4:before,.fa-thermometer-full:before,.fa-thermometer:before{content:""}.fa-thermometer-3:before,.fa-thermometer-three-quarters:before{content:""}.fa-thermometer-2:before,.fa-thermometer-half:before{content:""}.fa-thermometer-1:before,.fa-thermometer-quarter:before{content:""}.fa-thermometer-0:before,.fa-thermometer-empty:before{content:""}.fa-shower:before{content:""}.fa-bath:before,.fa-bathtub:before,.fa-s15:before{content:""}.fa-podcast:before{content:""}.fa-window-maximize:before{content:""}.fa-window-minimize:before{content:""}.fa-window-restore:before{content:""}.fa-times-rectangle:before,.fa-window-close:before{content:""}.fa-times-rectangle-o:before,.fa-window-close-o:before{content:""}.fa-bandcamp:before{content:""}.fa-grav:before{content:""}.fa-etsy:before{content:""}.fa-imdb:before{content:""}.fa-ravelry:before{content:""}.fa-eercast:before{content:""}.fa-microchip:before{content:""}.fa-snowflake-o:before{content:""}.fa-superpowers:before{content:""}.fa-wpexplorer:before{content:""}.fa-meetup:before{content:""}.sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);border:0}.sr-only-focusable:active,.sr-only-focusable:focus{position:static;width:auto;height:auto;margin:0;overflow:visible;clip:auto}.fa,.icon,.rst-content .admonition-title,.rst-content .code-block-caption .headerlink,.rst-content .eqno .headerlink,.rst-content code.download span:first-child,.rst-content dl dt .headerlink,.rst-content h1 .headerlink,.rst-content h2 .headerlink,.rst-content h3 .headerlink,.rst-content h4 .headerlink,.rst-content h5 .headerlink,.rst-content h6 .headerlink,.rst-content p.caption .headerlink,.rst-content p .headerlink,.rst-content table>caption .headerlink,.rst-content tt.download span:first-child,.wy-dropdown .caret,.wy-inline-validate.wy-inline-validate-danger .wy-input-context,.wy-inline-validate.wy-inline-validate-info .wy-input-context,.wy-inline-validate.wy-inline-validate-success .wy-input-context,.wy-inline-validate.wy-inline-validate-warning .wy-input-context,.wy-menu-vertical li.current>a button.toctree-expand,.wy-menu-vertical li.on a button.toctree-expand,.wy-menu-vertical li button.toctree-expand{font-family:inherit}.fa:before,.icon:before,.rst-content .admonition-title:before,.rst-content .code-block-caption .headerlink:before,.rst-content .eqno .headerlink:before,.rst-content code.download span:first-child:before,.rst-content dl dt .headerlink:before,.rst-content h1 .headerlink:before,.rst-content h2 .headerlink:before,.rst-content h3 .headerlink:before,.rst-content h4 .headerlink:before,.rst-content h5 .headerlink:before,.rst-content h6 .headerlink:before,.rst-content p.caption .headerlink:before,.rst-content p .headerlink:before,.rst-content table>caption .headerlink:before,.rst-content tt.download span:first-child:before,.wy-dropdown .caret:before,.wy-inline-validate.wy-inline-validate-danger .wy-input-context:before,.wy-inline-validate.wy-inline-validate-info .wy-input-context:before,.wy-inline-validate.wy-inline-validate-success .wy-input-context:before,.wy-inline-validate.wy-inline-validate-warning .wy-input-context:before,.wy-menu-vertical li.current>a button.toctree-expand:before,.wy-menu-vertical li.on a button.toctree-expand:before,.wy-menu-vertical li button.toctree-expand:before{font-family:FontAwesome;display:inline-block;font-style:normal;font-weight:400;line-height:1;text-decoration:inherit}.rst-content .code-block-caption a .headerlink,.rst-content .eqno a .headerlink,.rst-content a .admonition-title,.rst-content code.download a span:first-child,.rst-content dl dt a .headerlink,.rst-content h1 a .headerlink,.rst-content h2 a .headerlink,.rst-content h3 a .headerlink,.rst-content h4 a .headerlink,.rst-content h5 a .headerlink,.rst-content h6 a .headerlink,.rst-content p.caption a .headerlink,.rst-content p a .headerlink,.rst-content table>caption a .headerlink,.rst-content tt.download a span:first-child,.wy-menu-vertical li.current>a button.toctree-expand,.wy-menu-vertical li.on a button.toctree-expand,.wy-menu-vertical li a button.toctree-expand,a .fa,a .icon,a .rst-content .admonition-title,a .rst-content .code-block-caption .headerlink,a .rst-content .eqno .headerlink,a .rst-content code.download span:first-child,a .rst-content dl dt .headerlink,a .rst-content h1 .headerlink,a .rst-content h2 .headerlink,a .rst-content h3 .headerlink,a .rst-content h4 .headerlink,a .rst-content h5 .headerlink,a .rst-content h6 .headerlink,a .rst-content p.caption .headerlink,a .rst-content p .headerlink,a .rst-content table>caption .headerlink,a .rst-content tt.download span:first-child,a .wy-menu-vertical li button.toctree-expand{display:inline-block;text-decoration:inherit}.btn .fa,.btn .icon,.btn .rst-content .admonition-title,.btn .rst-content .code-block-caption .headerlink,.btn .rst-content .eqno .headerlink,.btn .rst-content code.download span:first-child,.btn .rst-content dl dt .headerlink,.btn .rst-content h1 .headerlink,.btn .rst-content h2 .headerlink,.btn .rst-content h3 .headerlink,.btn .rst-content h4 .headerlink,.btn .rst-content h5 .headerlink,.btn .rst-content h6 .headerlink,.btn .rst-content p .headerlink,.btn .rst-content table>caption .headerlink,.btn .rst-content tt.download span:first-child,.btn .wy-menu-vertical li.current>a button.toctree-expand,.btn .wy-menu-vertical li.on a button.toctree-expand,.btn .wy-menu-vertical li button.toctree-expand,.nav .fa,.nav .icon,.nav .rst-content .admonition-title,.nav .rst-content .code-block-caption .headerlink,.nav .rst-content .eqno .headerlink,.nav .rst-content code.download span:first-child,.nav .rst-content dl dt .headerlink,.nav .rst-content h1 .headerlink,.nav .rst-content h2 .headerlink,.nav .rst-content h3 .headerlink,.nav .rst-content h4 .headerlink,.nav .rst-content h5 .headerlink,.nav .rst-content h6 .headerlink,.nav .rst-content p .headerlink,.nav .rst-content table>caption .headerlink,.nav .rst-content tt.download span:first-child,.nav .wy-menu-vertical li.current>a button.toctree-expand,.nav .wy-menu-vertical li.on a button.toctree-expand,.nav .wy-menu-vertical li button.toctree-expand,.rst-content .btn .admonition-title,.rst-content .code-block-caption .btn .headerlink,.rst-content .code-block-caption .nav .headerlink,.rst-content .eqno .btn .headerlink,.rst-content .eqno .nav .headerlink,.rst-content .nav .admonition-title,.rst-content code.download .btn span:first-child,.rst-content code.download .nav span:first-child,.rst-content dl dt .btn .headerlink,.rst-content dl dt .nav .headerlink,.rst-content h1 .btn .headerlink,.rst-content h1 .nav .headerlink,.rst-content h2 .btn .headerlink,.rst-content h2 .nav .headerlink,.rst-content h3 .btn .headerlink,.rst-content h3 .nav .headerlink,.rst-content h4 .btn .headerlink,.rst-content h4 .nav .headerlink,.rst-content h5 .btn .headerlink,.rst-content h5 .nav .headerlink,.rst-content h6 .btn .headerlink,.rst-content h6 .nav .headerlink,.rst-content p .btn .headerlink,.rst-content p .nav .headerlink,.rst-content table>caption .btn .headerlink,.rst-content table>caption .nav .headerlink,.rst-content tt.download .btn span:first-child,.rst-content tt.download .nav span:first-child,.wy-menu-vertical li .btn button.toctree-expand,.wy-menu-vertical li.current>a .btn button.toctree-expand,.wy-menu-vertical li.current>a .nav button.toctree-expand,.wy-menu-vertical li .nav button.toctree-expand,.wy-menu-vertical li.on a .btn button.toctree-expand,.wy-menu-vertical li.on a .nav button.toctree-expand{display:inline}.btn .fa-large.icon,.btn .fa.fa-large,.btn .rst-content .code-block-caption .fa-large.headerlink,.btn .rst-content .eqno .fa-large.headerlink,.btn .rst-content .fa-large.admonition-title,.btn .rst-content code.download span.fa-large:first-child,.btn .rst-content dl dt .fa-large.headerlink,.btn .rst-content h1 .fa-large.headerlink,.btn .rst-content h2 .fa-large.headerlink,.btn .rst-content h3 .fa-large.headerlink,.btn .rst-content h4 .fa-large.headerlink,.btn .rst-content h5 .fa-large.headerlink,.btn .rst-content h6 .fa-large.headerlink,.btn .rst-content p .fa-large.headerlink,.btn .rst-content table>caption .fa-large.headerlink,.btn .rst-content tt.download span.fa-large:first-child,.btn .wy-menu-vertical li button.fa-large.toctree-expand,.nav .fa-large.icon,.nav .fa.fa-large,.nav .rst-content .code-block-caption .fa-large.headerlink,.nav .rst-content .eqno .fa-large.headerlink,.nav .rst-content .fa-large.admonition-title,.nav .rst-content code.download span.fa-large:first-child,.nav .rst-content dl dt .fa-large.headerlink,.nav .rst-content h1 .fa-large.headerlink,.nav .rst-content h2 .fa-large.headerlink,.nav .rst-content h3 .fa-large.headerlink,.nav .rst-content h4 .fa-large.headerlink,.nav .rst-content h5 .fa-large.headerlink,.nav .rst-content h6 .fa-large.headerlink,.nav .rst-content p .fa-large.headerlink,.nav .rst-content table>caption .fa-large.headerlink,.nav .rst-content tt.download span.fa-large:first-child,.nav .wy-menu-vertical li button.fa-large.toctree-expand,.rst-content .btn .fa-large.admonition-title,.rst-content .code-block-caption .btn .fa-large.headerlink,.rst-content .code-block-caption .nav .fa-large.headerlink,.rst-content .eqno .btn .fa-large.headerlink,.rst-content .eqno .nav .fa-large.headerlink,.rst-content .nav .fa-large.admonition-title,.rst-content code.download .btn span.fa-large:first-child,.rst-content code.download .nav span.fa-large:first-child,.rst-content dl dt .btn .fa-large.headerlink,.rst-content dl dt .nav .fa-large.headerlink,.rst-content h1 .btn .fa-large.headerlink,.rst-content h1 .nav .fa-large.headerlink,.rst-content h2 .btn .fa-large.headerlink,.rst-content h2 .nav .fa-large.headerlink,.rst-content h3 .btn .fa-large.headerlink,.rst-content h3 .nav .fa-large.headerlink,.rst-content h4 .btn .fa-large.headerlink,.rst-content h4 .nav .fa-large.headerlink,.rst-content h5 .btn .fa-large.headerlink,.rst-content h5 .nav .fa-large.headerlink,.rst-content h6 .btn .fa-large.headerlink,.rst-content h6 .nav .fa-large.headerlink,.rst-content p .btn .fa-large.headerlink,.rst-content p .nav .fa-large.headerlink,.rst-content table>caption .btn .fa-large.headerlink,.rst-content table>caption .nav .fa-large.headerlink,.rst-content tt.download .btn span.fa-large:first-child,.rst-content tt.download .nav span.fa-large:first-child,.wy-menu-vertical li .btn button.fa-large.toctree-expand,.wy-menu-vertical li .nav button.fa-large.toctree-expand{line-height:.9em}.btn .fa-spin.icon,.btn .fa.fa-spin,.btn .rst-content .code-block-caption .fa-spin.headerlink,.btn .rst-content .eqno .fa-spin.headerlink,.btn .rst-content .fa-spin.admonition-title,.btn .rst-content code.download span.fa-spin:first-child,.btn .rst-content dl dt .fa-spin.headerlink,.btn .rst-content h1 .fa-spin.headerlink,.btn .rst-content h2 .fa-spin.headerlink,.btn .rst-content h3 .fa-spin.headerlink,.btn .rst-content h4 .fa-spin.headerlink,.btn .rst-content h5 .fa-spin.headerlink,.btn .rst-content h6 .fa-spin.headerlink,.btn .rst-content p .fa-spin.headerlink,.btn .rst-content table>caption .fa-spin.headerlink,.btn .rst-content tt.download span.fa-spin:first-child,.btn .wy-menu-vertical li button.fa-spin.toctree-expand,.nav .fa-spin.icon,.nav .fa.fa-spin,.nav .rst-content .code-block-caption .fa-spin.headerlink,.nav .rst-content .eqno .fa-spin.headerlink,.nav .rst-content .fa-spin.admonition-title,.nav .rst-content code.download span.fa-spin:first-child,.nav .rst-content dl dt .fa-spin.headerlink,.nav .rst-content h1 .fa-spin.headerlink,.nav .rst-content h2 .fa-spin.headerlink,.nav .rst-content h3 .fa-spin.headerlink,.nav .rst-content h4 .fa-spin.headerlink,.nav .rst-content h5 .fa-spin.headerlink,.nav .rst-content h6 .fa-spin.headerlink,.nav .rst-content p .fa-spin.headerlink,.nav .rst-content table>caption .fa-spin.headerlink,.nav .rst-content tt.download span.fa-spin:first-child,.nav .wy-menu-vertical li button.fa-spin.toctree-expand,.rst-content .btn .fa-spin.admonition-title,.rst-content .code-block-caption .btn .fa-spin.headerlink,.rst-content .code-block-caption .nav .fa-spin.headerlink,.rst-content .eqno .btn .fa-spin.headerlink,.rst-content .eqno .nav .fa-spin.headerlink,.rst-content .nav .fa-spin.admonition-title,.rst-content code.download .btn span.fa-spin:first-child,.rst-content code.download .nav span.fa-spin:first-child,.rst-content dl dt .btn .fa-spin.headerlink,.rst-content dl dt .nav .fa-spin.headerlink,.rst-content h1 .btn .fa-spin.headerlink,.rst-content h1 .nav .fa-spin.headerlink,.rst-content h2 .btn .fa-spin.headerlink,.rst-content h2 .nav .fa-spin.headerlink,.rst-content h3 .btn .fa-spin.headerlink,.rst-content h3 .nav .fa-spin.headerlink,.rst-content h4 .btn .fa-spin.headerlink,.rst-content h4 .nav .fa-spin.headerlink,.rst-content h5 .btn .fa-spin.headerlink,.rst-content h5 .nav .fa-spin.headerlink,.rst-content h6 .btn .fa-spin.headerlink,.rst-content h6 .nav .fa-spin.headerlink,.rst-content p .btn .fa-spin.headerlink,.rst-content p .nav .fa-spin.headerlink,.rst-content table>caption .btn .fa-spin.headerlink,.rst-content table>caption .nav .fa-spin.headerlink,.rst-content tt.download .btn span.fa-spin:first-child,.rst-content tt.download .nav span.fa-spin:first-child,.wy-menu-vertical li .btn button.fa-spin.toctree-expand,.wy-menu-vertical li .nav button.fa-spin.toctree-expand{display:inline-block}.btn.fa:before,.btn.icon:before,.rst-content .btn.admonition-title:before,.rst-content .code-block-caption .btn.headerlink:before,.rst-content .eqno .btn.headerlink:before,.rst-content code.download span.btn:first-child:before,.rst-content dl dt .btn.headerlink:before,.rst-content h1 .btn.headerlink:before,.rst-content h2 .btn.headerlink:before,.rst-content h3 .btn.headerlink:before,.rst-content h4 .btn.headerlink:before,.rst-content h5 .btn.headerlink:before,.rst-content h6 .btn.headerlink:before,.rst-content p .btn.headerlink:before,.rst-content table>caption .btn.headerlink:before,.rst-content tt.download span.btn:first-child:before,.wy-menu-vertical li button.btn.toctree-expand:before{opacity:.5;-webkit-transition:opacity .05s ease-in;-moz-transition:opacity .05s ease-in;transition:opacity .05s ease-in}.btn.fa:hover:before,.btn.icon:hover:before,.rst-content .btn.admonition-title:hover:before,.rst-content .code-block-caption .btn.headerlink:hover:before,.rst-content .eqno .btn.headerlink:hover:before,.rst-content code.download span.btn:first-child:hover:before,.rst-content dl dt .btn.headerlink:hover:before,.rst-content h1 .btn.headerlink:hover:before,.rst-content h2 .btn.headerlink:hover:before,.rst-content h3 .btn.headerlink:hover:before,.rst-content h4 .btn.headerlink:hover:before,.rst-content h5 .btn.headerlink:hover:before,.rst-content h6 .btn.headerlink:hover:before,.rst-content p .btn.headerlink:hover:before,.rst-content table>caption .btn.headerlink:hover:before,.rst-content tt.download span.btn:first-child:hover:before,.wy-menu-vertical li button.btn.toctree-expand:hover:before{opacity:1}.btn-mini .fa:before,.btn-mini .icon:before,.btn-mini .rst-content .admonition-title:before,.btn-mini .rst-content .code-block-caption .headerlink:before,.btn-mini .rst-content .eqno .headerlink:before,.btn-mini .rst-content code.download span:first-child:before,.btn-mini .rst-content dl dt .headerlink:before,.btn-mini .rst-content h1 .headerlink:before,.btn-mini .rst-content h2 .headerlink:before,.btn-mini .rst-content h3 .headerlink:before,.btn-mini .rst-content h4 .headerlink:before,.btn-mini .rst-content h5 .headerlink:before,.btn-mini .rst-content h6 .headerlink:before,.btn-mini .rst-content p .headerlink:before,.btn-mini .rst-content table>caption .headerlink:before,.btn-mini .rst-content tt.download span:first-child:before,.btn-mini .wy-menu-vertical li button.toctree-expand:before,.rst-content .btn-mini .admonition-title:before,.rst-content .code-block-caption .btn-mini .headerlink:before,.rst-content .eqno .btn-mini .headerlink:before,.rst-content code.download .btn-mini span:first-child:before,.rst-content dl dt .btn-mini .headerlink:before,.rst-content h1 .btn-mini .headerlink:before,.rst-content h2 .btn-mini .headerlink:before,.rst-content h3 .btn-mini .headerlink:before,.rst-content h4 .btn-mini .headerlink:before,.rst-content h5 .btn-mini .headerlink:before,.rst-content h6 .btn-mini .headerlink:before,.rst-content p .btn-mini .headerlink:before,.rst-content table>caption .btn-mini .headerlink:before,.rst-content tt.download .btn-mini span:first-child:before,.wy-menu-vertical li .btn-mini button.toctree-expand:before{font-size:14px;vertical-align:-15%}.rst-content .admonition,.rst-content .admonition-todo,.rst-content .attention,.rst-content .caution,.rst-content .danger,.rst-content .error,.rst-content .hint,.rst-content .important,.rst-content .note,.rst-content .seealso,.rst-content .tip,.rst-content .warning,.wy-alert{padding:12px;line-height:24px;margin-bottom:24px;background:#e7f2fa}.rst-content .admonition-title,.wy-alert-title{font-weight:700;display:block;color:#fff;background:#6ab0de;padding:6px 12px;margin:-12px -12px 12px}.rst-content .danger,.rst-content .error,.rst-content .wy-alert-danger.admonition,.rst-content .wy-alert-danger.admonition-todo,.rst-content .wy-alert-danger.attention,.rst-content .wy-alert-danger.caution,.rst-content .wy-alert-danger.hint,.rst-content .wy-alert-danger.important,.rst-content .wy-alert-danger.note,.rst-content .wy-alert-danger.seealso,.rst-content .wy-alert-danger.tip,.rst-content .wy-alert-danger.warning,.wy-alert.wy-alert-danger{background:#fdf3f2}.rst-content .danger .admonition-title,.rst-content .danger .wy-alert-title,.rst-content .error .admonition-title,.rst-content .error .wy-alert-title,.rst-content .wy-alert-danger.admonition-todo .admonition-title,.rst-content .wy-alert-danger.admonition-todo .wy-alert-title,.rst-content .wy-alert-danger.admonition .admonition-title,.rst-content .wy-alert-danger.admonition .wy-alert-title,.rst-content .wy-alert-danger.attention .admonition-title,.rst-content .wy-alert-danger.attention .wy-alert-title,.rst-content .wy-alert-danger.caution .admonition-title,.rst-content .wy-alert-danger.caution .wy-alert-title,.rst-content .wy-alert-danger.hint .admonition-title,.rst-content .wy-alert-danger.hint .wy-alert-title,.rst-content .wy-alert-danger.important .admonition-title,.rst-content .wy-alert-danger.important .wy-alert-title,.rst-content .wy-alert-danger.note .admonition-title,.rst-content .wy-alert-danger.note .wy-alert-title,.rst-content .wy-alert-danger.seealso .admonition-title,.rst-content .wy-alert-danger.seealso .wy-alert-title,.rst-content .wy-alert-danger.tip .admonition-title,.rst-content .wy-alert-danger.tip .wy-alert-title,.rst-content .wy-alert-danger.warning .admonition-title,.rst-content .wy-alert-danger.warning .wy-alert-title,.rst-content .wy-alert.wy-alert-danger .admonition-title,.wy-alert.wy-alert-danger .rst-content .admonition-title,.wy-alert.wy-alert-danger .wy-alert-title{background:#f29f97}.rst-content .admonition-todo,.rst-content .attention,.rst-content .caution,.rst-content .warning,.rst-content .wy-alert-warning.admonition,.rst-content .wy-alert-warning.danger,.rst-content .wy-alert-warning.error,.rst-content .wy-alert-warning.hint,.rst-content .wy-alert-warning.important,.rst-content .wy-alert-warning.note,.rst-content .wy-alert-warning.seealso,.rst-content .wy-alert-warning.tip,.wy-alert.wy-alert-warning{background:#ffedcc}.rst-content .admonition-todo .admonition-title,.rst-content .admonition-todo .wy-alert-title,.rst-content .attention .admonition-title,.rst-content .attention .wy-alert-title,.rst-content .caution .admonition-title,.rst-content .caution .wy-alert-title,.rst-content .warning .admonition-title,.rst-content .warning .wy-alert-title,.rst-content .wy-alert-warning.admonition .admonition-title,.rst-content .wy-alert-warning.admonition .wy-alert-title,.rst-content .wy-alert-warning.danger .admonition-title,.rst-content .wy-alert-warning.danger .wy-alert-title,.rst-content .wy-alert-warning.error .admonition-title,.rst-content .wy-alert-warning.error .wy-alert-title,.rst-content .wy-alert-warning.hint .admonition-title,.rst-content .wy-alert-warning.hint .wy-alert-title,.rst-content .wy-alert-warning.important .admonition-title,.rst-content .wy-alert-warning.important .wy-alert-title,.rst-content .wy-alert-warning.note .admonition-title,.rst-content .wy-alert-warning.note .wy-alert-title,.rst-content .wy-alert-warning.seealso .admonition-title,.rst-content .wy-alert-warning.seealso .wy-alert-title,.rst-content .wy-alert-warning.tip .admonition-title,.rst-content .wy-alert-warning.tip .wy-alert-title,.rst-content .wy-alert.wy-alert-warning .admonition-title,.wy-alert.wy-alert-warning .rst-content .admonition-title,.wy-alert.wy-alert-warning .wy-alert-title{background:#f0b37e}.rst-content .note,.rst-content .seealso,.rst-content .wy-alert-info.admonition,.rst-content .wy-alert-info.admonition-todo,.rst-content .wy-alert-info.attention,.rst-content .wy-alert-info.caution,.rst-content .wy-alert-info.danger,.rst-content .wy-alert-info.error,.rst-content .wy-alert-info.hint,.rst-content .wy-alert-info.important,.rst-content .wy-alert-info.tip,.rst-content .wy-alert-info.warning,.wy-alert.wy-alert-info{background:#e7f2fa}.rst-content .note .admonition-title,.rst-content .note .wy-alert-title,.rst-content .seealso .admonition-title,.rst-content .seealso .wy-alert-title,.rst-content .wy-alert-info.admonition-todo .admonition-title,.rst-content .wy-alert-info.admonition-todo .wy-alert-title,.rst-content .wy-alert-info.admonition .admonition-title,.rst-content .wy-alert-info.admonition .wy-alert-title,.rst-content .wy-alert-info.attention .admonition-title,.rst-content .wy-alert-info.attention .wy-alert-title,.rst-content .wy-alert-info.caution .admonition-title,.rst-content .wy-alert-info.caution .wy-alert-title,.rst-content .wy-alert-info.danger .admonition-title,.rst-content .wy-alert-info.danger .wy-alert-title,.rst-content .wy-alert-info.error .admonition-title,.rst-content .wy-alert-info.error .wy-alert-title,.rst-content .wy-alert-info.hint .admonition-title,.rst-content .wy-alert-info.hint .wy-alert-title,.rst-content .wy-alert-info.important .admonition-title,.rst-content .wy-alert-info.important .wy-alert-title,.rst-content .wy-alert-info.tip .admonition-title,.rst-content .wy-alert-info.tip .wy-alert-title,.rst-content .wy-alert-info.warning .admonition-title,.rst-content .wy-alert-info.warning .wy-alert-title,.rst-content .wy-alert.wy-alert-info .admonition-title,.wy-alert.wy-alert-info .rst-content .admonition-title,.wy-alert.wy-alert-info .wy-alert-title{background:#6ab0de}.rst-content .hint,.rst-content .important,.rst-content .tip,.rst-content .wy-alert-success.admonition,.rst-content .wy-alert-success.admonition-todo,.rst-content .wy-alert-success.attention,.rst-content .wy-alert-success.caution,.rst-content .wy-alert-success.danger,.rst-content .wy-alert-success.error,.rst-content .wy-alert-success.note,.rst-content .wy-alert-success.seealso,.rst-content .wy-alert-success.warning,.wy-alert.wy-alert-success{background:#dbfaf4}.rst-content .hint .admonition-title,.rst-content .hint .wy-alert-title,.rst-content .important .admonition-title,.rst-content .important .wy-alert-title,.rst-content .tip .admonition-title,.rst-content .tip .wy-alert-title,.rst-content .wy-alert-success.admonition-todo .admonition-title,.rst-content .wy-alert-success.admonition-todo .wy-alert-title,.rst-content .wy-alert-success.admonition .admonition-title,.rst-content .wy-alert-success.admonition .wy-alert-title,.rst-content .wy-alert-success.attention .admonition-title,.rst-content .wy-alert-success.attention .wy-alert-title,.rst-content .wy-alert-success.caution .admonition-title,.rst-content .wy-alert-success.caution .wy-alert-title,.rst-content .wy-alert-success.danger .admonition-title,.rst-content .wy-alert-success.danger .wy-alert-title,.rst-content .wy-alert-success.error .admonition-title,.rst-content .wy-alert-success.error .wy-alert-title,.rst-content .wy-alert-success.note .admonition-title,.rst-content .wy-alert-success.note .wy-alert-title,.rst-content .wy-alert-success.seealso .admonition-title,.rst-content .wy-alert-success.seealso .wy-alert-title,.rst-content .wy-alert-success.warning .admonition-title,.rst-content .wy-alert-success.warning .wy-alert-title,.rst-content .wy-alert.wy-alert-success .admonition-title,.wy-alert.wy-alert-success .rst-content .admonition-title,.wy-alert.wy-alert-success .wy-alert-title{background:#1abc9c}.rst-content .wy-alert-neutral.admonition,.rst-content .wy-alert-neutral.admonition-todo,.rst-content .wy-alert-neutral.attention,.rst-content .wy-alert-neutral.caution,.rst-content .wy-alert-neutral.danger,.rst-content .wy-alert-neutral.error,.rst-content .wy-alert-neutral.hint,.rst-content .wy-alert-neutral.important,.rst-content .wy-alert-neutral.note,.rst-content .wy-alert-neutral.seealso,.rst-content .wy-alert-neutral.tip,.rst-content .wy-alert-neutral.warning,.wy-alert.wy-alert-neutral{background:#f3f6f6}.rst-content .wy-alert-neutral.admonition-todo .admonition-title,.rst-content .wy-alert-neutral.admonition-todo .wy-alert-title,.rst-content .wy-alert-neutral.admonition .admonition-title,.rst-content .wy-alert-neutral.admonition .wy-alert-title,.rst-content .wy-alert-neutral.attention .admonition-title,.rst-content .wy-alert-neutral.attention .wy-alert-title,.rst-content .wy-alert-neutral.caution .admonition-title,.rst-content .wy-alert-neutral.caution .wy-alert-title,.rst-content .wy-alert-neutral.danger .admonition-title,.rst-content .wy-alert-neutral.danger .wy-alert-title,.rst-content .wy-alert-neutral.error .admonition-title,.rst-content .wy-alert-neutral.error .wy-alert-title,.rst-content .wy-alert-neutral.hint .admonition-title,.rst-content .wy-alert-neutral.hint .wy-alert-title,.rst-content .wy-alert-neutral.important .admonition-title,.rst-content .wy-alert-neutral.important .wy-alert-title,.rst-content .wy-alert-neutral.note .admonition-title,.rst-content .wy-alert-neutral.note .wy-alert-title,.rst-content .wy-alert-neutral.seealso .admonition-title,.rst-content .wy-alert-neutral.seealso .wy-alert-title,.rst-content .wy-alert-neutral.tip .admonition-title,.rst-content .wy-alert-neutral.tip .wy-alert-title,.rst-content .wy-alert-neutral.warning .admonition-title,.rst-content .wy-alert-neutral.warning .wy-alert-title,.rst-content .wy-alert.wy-alert-neutral .admonition-title,.wy-alert.wy-alert-neutral .rst-content .admonition-title,.wy-alert.wy-alert-neutral .wy-alert-title{color:#404040;background:#e1e4e5}.rst-content .wy-alert-neutral.admonition-todo a,.rst-content .wy-alert-neutral.admonition a,.rst-content .wy-alert-neutral.attention a,.rst-content .wy-alert-neutral.caution a,.rst-content .wy-alert-neutral.danger a,.rst-content .wy-alert-neutral.error a,.rst-content .wy-alert-neutral.hint a,.rst-content .wy-alert-neutral.important a,.rst-content .wy-alert-neutral.note a,.rst-content .wy-alert-neutral.seealso a,.rst-content .wy-alert-neutral.tip a,.rst-content .wy-alert-neutral.warning a,.wy-alert.wy-alert-neutral a{color:#2980b9}.rst-content .admonition-todo p:last-child,.rst-content .admonition p:last-child,.rst-content .attention p:last-child,.rst-content .caution p:last-child,.rst-content .danger p:last-child,.rst-content .error p:last-child,.rst-content .hint p:last-child,.rst-content .important p:last-child,.rst-content .note p:last-child,.rst-content .seealso p:last-child,.rst-content .tip p:last-child,.rst-content .warning p:last-child,.wy-alert p:last-child{margin-bottom:0}.wy-tray-container{position:fixed;bottom:0;left:0;z-index:600}.wy-tray-container li{display:block;width:300px;background:transparent;color:#fff;text-align:center;box-shadow:0 5px 5px 0 rgba(0,0,0,.1);padding:0 24px;min-width:20%;opacity:0;height:0;line-height:56px;overflow:hidden;-webkit-transition:all .3s ease-in;-moz-transition:all .3s ease-in;transition:all .3s ease-in}.wy-tray-container li.wy-tray-item-success{background:#27ae60}.wy-tray-container li.wy-tray-item-info{background:#2980b9}.wy-tray-container li.wy-tray-item-warning{background:#e67e22}.wy-tray-container li.wy-tray-item-danger{background:#e74c3c}.wy-tray-container li.on{opacity:1;height:56px}@media screen and (max-width:768px){.wy-tray-container{bottom:auto;top:0;width:100%}.wy-tray-container li{width:100%}}button{font-size:100%;margin:0;vertical-align:baseline;*vertical-align:middle;cursor:pointer;line-height:normal;-webkit-appearance:button;*overflow:visible}button::-moz-focus-inner,input::-moz-focus-inner{border:0;padding:0}button[disabled]{cursor:default}.btn{display:inline-block;border-radius:2px;line-height:normal;white-space:nowrap;text-align:center;cursor:pointer;font-size:100%;padding:6px 12px 8px;color:#fff;border:1px solid rgba(0,0,0,.1);background-color:#27ae60;text-decoration:none;font-weight:400;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;box-shadow:inset 0 1px 2px -1px hsla(0,0%,100%,.5),inset 0 -2px 0 0 rgba(0,0,0,.1);outline-none:false;vertical-align:middle;*display:inline;zoom:1;-webkit-user-drag:none;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;-webkit-transition:all .1s linear;-moz-transition:all .1s linear;transition:all .1s linear}.btn-hover{background:#2e8ece;color:#fff}.btn:hover{background:#2cc36b;color:#fff}.btn:focus{background:#2cc36b;outline:0}.btn:active{box-shadow:inset 0 -1px 0 0 rgba(0,0,0,.05),inset 0 2px 0 0 rgba(0,0,0,.1);padding:8px 12px 6px}.btn:visited{color:#fff}.btn-disabled,.btn-disabled:active,.btn-disabled:focus,.btn-disabled:hover,.btn:disabled{background-image:none;filter:progid:DXImageTransform.Microsoft.gradient(enabled = false);filter:alpha(opacity=40);opacity:.4;cursor:not-allowed;box-shadow:none}.btn::-moz-focus-inner{padding:0;border:0}.btn-small{font-size:80%}.btn-info{background-color:#2980b9!important}.btn-info:hover{background-color:#2e8ece!important}.btn-neutral{background-color:#f3f6f6!important;color:#404040!important}.btn-neutral:hover{background-color:#e5ebeb!important;color:#404040}.btn-neutral:visited{color:#404040!important}.btn-success{background-color:#27ae60!important}.btn-success:hover{background-color:#295!important}.btn-danger{background-color:#e74c3c!important}.btn-danger:hover{background-color:#ea6153!important}.btn-warning{background-color:#e67e22!important}.btn-warning:hover{background-color:#e98b39!important}.btn-invert{background-color:#222}.btn-invert:hover{background-color:#2f2f2f!important}.btn-link{background-color:transparent!important;color:#2980b9;box-shadow:none;border-color:transparent!important}.btn-link:active,.btn-link:hover{background-color:transparent!important;color:#409ad5!important;box-shadow:none}.btn-link:visited{color:#9b59b6}.wy-btn-group .btn,.wy-control .btn{vertical-align:middle}.wy-btn-group{margin-bottom:24px;*zoom:1}.wy-btn-group:after,.wy-btn-group:before{display:table;content:""}.wy-btn-group:after{clear:both}.wy-dropdown{position:relative;display:inline-block}.wy-dropdown-active .wy-dropdown-menu{display:block}.wy-dropdown-menu{position:absolute;left:0;display:none;float:left;top:100%;min-width:100%;background:#fcfcfc;z-index:100;border:1px solid #cfd7dd;box-shadow:0 2px 2px 0 rgba(0,0,0,.1);padding:12px}.wy-dropdown-menu>dd>a{display:block;clear:both;color:#404040;white-space:nowrap;font-size:90%;padding:0 12px;cursor:pointer}.wy-dropdown-menu>dd>a:hover{background:#2980b9;color:#fff}.wy-dropdown-menu>dd.divider{border-top:1px solid #cfd7dd;margin:6px 0}.wy-dropdown-menu>dd.search{padding-bottom:12px}.wy-dropdown-menu>dd.search input[type=search]{width:100%}.wy-dropdown-menu>dd.call-to-action{background:#e3e3e3;text-transform:uppercase;font-weight:500;font-size:80%}.wy-dropdown-menu>dd.call-to-action:hover{background:#e3e3e3}.wy-dropdown-menu>dd.call-to-action .btn{color:#fff}.wy-dropdown.wy-dropdown-up .wy-dropdown-menu{bottom:100%;top:auto;left:auto;right:0}.wy-dropdown.wy-dropdown-bubble .wy-dropdown-menu{background:#fcfcfc;margin-top:2px}.wy-dropdown.wy-dropdown-bubble .wy-dropdown-menu a{padding:6px 12px}.wy-dropdown.wy-dropdown-bubble .wy-dropdown-menu a:hover{background:#2980b9;color:#fff}.wy-dropdown.wy-dropdown-left .wy-dropdown-menu{right:0;left:auto;text-align:right}.wy-dropdown-arrow:before{content:" ";border-bottom:5px solid #f5f5f5;border-left:5px solid transparent;border-right:5px solid transparent;position:absolute;display:block;top:-4px;left:50%;margin-left:-3px}.wy-dropdown-arrow.wy-dropdown-arrow-left:before{left:11px}.wy-form-stacked select{display:block}.wy-form-aligned .wy-help-inline,.wy-form-aligned input,.wy-form-aligned label,.wy-form-aligned select,.wy-form-aligned textarea{display:inline-block;*display:inline;*zoom:1;vertical-align:middle}.wy-form-aligned .wy-control-group>label{display:inline-block;vertical-align:middle;width:10em;margin:6px 12px 0 0;float:left}.wy-form-aligned .wy-control{float:left}.wy-form-aligned .wy-control label{display:block}.wy-form-aligned .wy-control select{margin-top:6px}fieldset{margin:0}fieldset,legend{border:0;padding:0}legend{width:100%;white-space:normal;margin-bottom:24px;font-size:150%;*margin-left:-7px}label,legend{display:block}label{margin:0 0 .3125em;color:#333;font-size:90%}input,select,textarea{font-size:100%;margin:0;vertical-align:baseline;*vertical-align:middle}.wy-control-group{margin-bottom:24px;max-width:1200px;margin-left:auto;margin-right:auto;*zoom:1}.wy-control-group:after,.wy-control-group:before{display:table;content:""}.wy-control-group:after{clear:both}.wy-control-group.wy-control-group-required>label:after{content:" *";color:#e74c3c}.wy-control-group .wy-form-full,.wy-control-group .wy-form-halves,.wy-control-group .wy-form-thirds{padding-bottom:12px}.wy-control-group .wy-form-full input[type=color],.wy-control-group .wy-form-full input[type=date],.wy-control-group .wy-form-full input[type=datetime-local],.wy-control-group .wy-form-full input[type=datetime],.wy-control-group .wy-form-full input[type=email],.wy-control-group .wy-form-full input[type=month],.wy-control-group .wy-form-full input[type=number],.wy-control-group .wy-form-full input[type=password],.wy-control-group .wy-form-full input[type=search],.wy-control-group .wy-form-full input[type=tel],.wy-control-group .wy-form-full input[type=text],.wy-control-group .wy-form-full input[type=time],.wy-control-group .wy-form-full input[type=url],.wy-control-group .wy-form-full input[type=week],.wy-control-group .wy-form-full select,.wy-control-group .wy-form-halves input[type=color],.wy-control-group .wy-form-halves input[type=date],.wy-control-group .wy-form-halves input[type=datetime-local],.wy-control-group .wy-form-halves input[type=datetime],.wy-control-group .wy-form-halves input[type=email],.wy-control-group .wy-form-halves input[type=month],.wy-control-group .wy-form-halves input[type=number],.wy-control-group .wy-form-halves input[type=password],.wy-control-group .wy-form-halves input[type=search],.wy-control-group .wy-form-halves input[type=tel],.wy-control-group .wy-form-halves input[type=text],.wy-control-group .wy-form-halves input[type=time],.wy-control-group .wy-form-halves input[type=url],.wy-control-group .wy-form-halves input[type=week],.wy-control-group .wy-form-halves select,.wy-control-group .wy-form-thirds input[type=color],.wy-control-group .wy-form-thirds input[type=date],.wy-control-group .wy-form-thirds input[type=datetime-local],.wy-control-group .wy-form-thirds input[type=datetime],.wy-control-group .wy-form-thirds input[type=email],.wy-control-group .wy-form-thirds input[type=month],.wy-control-group .wy-form-thirds input[type=number],.wy-control-group .wy-form-thirds input[type=password],.wy-control-group .wy-form-thirds input[type=search],.wy-control-group .wy-form-thirds input[type=tel],.wy-control-group .wy-form-thirds input[type=text],.wy-control-group .wy-form-thirds input[type=time],.wy-control-group .wy-form-thirds input[type=url],.wy-control-group .wy-form-thirds input[type=week],.wy-control-group .wy-form-thirds select{width:100%}.wy-control-group .wy-form-full{float:left;display:block;width:100%;margin-right:0}.wy-control-group .wy-form-full:last-child{margin-right:0}.wy-control-group .wy-form-halves{float:left;display:block;margin-right:2.35765%;width:48.82117%}.wy-control-group .wy-form-halves:last-child,.wy-control-group .wy-form-halves:nth-of-type(2n){margin-right:0}.wy-control-group .wy-form-halves:nth-of-type(odd){clear:left}.wy-control-group .wy-form-thirds{float:left;display:block;margin-right:2.35765%;width:31.76157%}.wy-control-group .wy-form-thirds:last-child,.wy-control-group .wy-form-thirds:nth-of-type(3n){margin-right:0}.wy-control-group .wy-form-thirds:nth-of-type(3n+1){clear:left}.wy-control-group.wy-control-group-no-input .wy-control,.wy-control-no-input{margin:6px 0 0;font-size:90%}.wy-control-no-input{display:inline-block}.wy-control-group.fluid-input input[type=color],.wy-control-group.fluid-input input[type=date],.wy-control-group.fluid-input input[type=datetime-local],.wy-control-group.fluid-input input[type=datetime],.wy-control-group.fluid-input input[type=email],.wy-control-group.fluid-input input[type=month],.wy-control-group.fluid-input input[type=number],.wy-control-group.fluid-input input[type=password],.wy-control-group.fluid-input input[type=search],.wy-control-group.fluid-input input[type=tel],.wy-control-group.fluid-input input[type=text],.wy-control-group.fluid-input input[type=time],.wy-control-group.fluid-input input[type=url],.wy-control-group.fluid-input input[type=week]{width:100%}.wy-form-message-inline{padding-left:.3em;color:#666;font-size:90%}.wy-form-message{display:block;color:#999;font-size:70%;margin-top:.3125em;font-style:italic}.wy-form-message p{font-size:inherit;font-style:italic;margin-bottom:6px}.wy-form-message p:last-child{margin-bottom:0}input{line-height:normal}input[type=button],input[type=reset],input[type=submit]{-webkit-appearance:button;cursor:pointer;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;*overflow:visible}input[type=color],input[type=date],input[type=datetime-local],input[type=datetime],input[type=email],input[type=month],input[type=number],input[type=password],input[type=search],input[type=tel],input[type=text],input[type=time],input[type=url],input[type=week]{-webkit-appearance:none;padding:6px;display:inline-block;border:1px solid #ccc;font-size:80%;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;box-shadow:inset 0 1px 3px #ddd;border-radius:0;-webkit-transition:border .3s linear;-moz-transition:border .3s linear;transition:border .3s linear}input[type=datetime-local]{padding:.34375em .625em}input[disabled]{cursor:default}input[type=checkbox],input[type=radio]{padding:0;margin-right:.3125em;*height:13px;*width:13px}input[type=checkbox],input[type=radio],input[type=search]{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}input[type=search]::-webkit-search-cancel-button,input[type=search]::-webkit-search-decoration{-webkit-appearance:none}input[type=color]:focus,input[type=date]:focus,input[type=datetime-local]:focus,input[type=datetime]:focus,input[type=email]:focus,input[type=month]:focus,input[type=number]:focus,input[type=password]:focus,input[type=search]:focus,input[type=tel]:focus,input[type=text]:focus,input[type=time]:focus,input[type=url]:focus,input[type=week]:focus{outline:0;outline:thin dotted\9;border-color:#333}input.no-focus:focus{border-color:#ccc!important}input[type=checkbox]:focus,input[type=file]:focus,input[type=radio]:focus{outline:thin dotted #333;outline:1px auto #129fea}input[type=color][disabled],input[type=date][disabled],input[type=datetime-local][disabled],input[type=datetime][disabled],input[type=email][disabled],input[type=month][disabled],input[type=number][disabled],input[type=password][disabled],input[type=search][disabled],input[type=tel][disabled],input[type=text][disabled],input[type=time][disabled],input[type=url][disabled],input[type=week][disabled]{cursor:not-allowed;background-color:#fafafa}input:focus:invalid,select:focus:invalid,textarea:focus:invalid{color:#e74c3c;border:1px solid #e74c3c}input:focus:invalid:focus,select:focus:invalid:focus,textarea:focus:invalid:focus{border-color:#e74c3c}input[type=checkbox]:focus:invalid:focus,input[type=file]:focus:invalid:focus,input[type=radio]:focus:invalid:focus{outline-color:#e74c3c}input.wy-input-large{padding:12px;font-size:100%}textarea{overflow:auto;vertical-align:top;width:100%;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif}select,textarea{padding:.5em .625em;display:inline-block;border:1px solid #ccc;font-size:80%;box-shadow:inset 0 1px 3px #ddd;-webkit-transition:border .3s linear;-moz-transition:border .3s linear;transition:border .3s linear}select{border:1px solid #ccc;background-color:#fff}select[multiple]{height:auto}select:focus,textarea:focus{outline:0}input[readonly],select[disabled],select[readonly],textarea[disabled],textarea[readonly]{cursor:not-allowed;background-color:#fafafa}input[type=checkbox][disabled],input[type=radio][disabled]{cursor:not-allowed}.wy-checkbox,.wy-radio{margin:6px 0;color:#404040;display:block}.wy-checkbox input,.wy-radio input{vertical-align:baseline}.wy-form-message-inline{display:inline-block;*display:inline;*zoom:1;vertical-align:middle}.wy-input-prefix,.wy-input-suffix{white-space:nowrap;padding:6px}.wy-input-prefix .wy-input-context,.wy-input-suffix .wy-input-context{line-height:27px;padding:0 8px;display:inline-block;font-size:80%;background-color:#f3f6f6;border:1px solid #ccc;color:#999}.wy-input-suffix .wy-input-context{border-left:0}.wy-input-prefix .wy-input-context{border-right:0}.wy-switch{position:relative;display:block;height:24px;margin-top:12px;cursor:pointer}.wy-switch:before{left:0;top:0;width:36px;height:12px;background:#ccc}.wy-switch:after,.wy-switch:before{position:absolute;content:"";display:block;border-radius:4px;-webkit-transition:all .2s ease-in-out;-moz-transition:all .2s ease-in-out;transition:all .2s ease-in-out}.wy-switch:after{width:18px;height:18px;background:#999;left:-3px;top:-3px}.wy-switch span{position:absolute;left:48px;display:block;font-size:12px;color:#ccc;line-height:1}.wy-switch.active:before{background:#1e8449}.wy-switch.active:after{left:24px;background:#27ae60}.wy-switch.disabled{cursor:not-allowed;opacity:.8}.wy-control-group.wy-control-group-error .wy-form-message,.wy-control-group.wy-control-group-error>label{color:#e74c3c}.wy-control-group.wy-control-group-error input[type=color],.wy-control-group.wy-control-group-error input[type=date],.wy-control-group.wy-control-group-error input[type=datetime-local],.wy-control-group.wy-control-group-error input[type=datetime],.wy-control-group.wy-control-group-error input[type=email],.wy-control-group.wy-control-group-error input[type=month],.wy-control-group.wy-control-group-error input[type=number],.wy-control-group.wy-control-group-error input[type=password],.wy-control-group.wy-control-group-error input[type=search],.wy-control-group.wy-control-group-error input[type=tel],.wy-control-group.wy-control-group-error input[type=text],.wy-control-group.wy-control-group-error input[type=time],.wy-control-group.wy-control-group-error input[type=url],.wy-control-group.wy-control-group-error input[type=week],.wy-control-group.wy-control-group-error textarea{border:1px solid #e74c3c}.wy-inline-validate{white-space:nowrap}.wy-inline-validate .wy-input-context{padding:.5em .625em;display:inline-block;font-size:80%}.wy-inline-validate.wy-inline-validate-success .wy-input-context{color:#27ae60}.wy-inline-validate.wy-inline-validate-danger .wy-input-context{color:#e74c3c}.wy-inline-validate.wy-inline-validate-warning .wy-input-context{color:#e67e22}.wy-inline-validate.wy-inline-validate-info .wy-input-context{color:#2980b9}.rotate-90{-webkit-transform:rotate(90deg);-moz-transform:rotate(90deg);-ms-transform:rotate(90deg);-o-transform:rotate(90deg);transform:rotate(90deg)}.rotate-180{-webkit-transform:rotate(180deg);-moz-transform:rotate(180deg);-ms-transform:rotate(180deg);-o-transform:rotate(180deg);transform:rotate(180deg)}.rotate-270{-webkit-transform:rotate(270deg);-moz-transform:rotate(270deg);-ms-transform:rotate(270deg);-o-transform:rotate(270deg);transform:rotate(270deg)}.mirror{-webkit-transform:scaleX(-1);-moz-transform:scaleX(-1);-ms-transform:scaleX(-1);-o-transform:scaleX(-1);transform:scaleX(-1)}.mirror.rotate-90{-webkit-transform:scaleX(-1) rotate(90deg);-moz-transform:scaleX(-1) rotate(90deg);-ms-transform:scaleX(-1) rotate(90deg);-o-transform:scaleX(-1) rotate(90deg);transform:scaleX(-1) rotate(90deg)}.mirror.rotate-180{-webkit-transform:scaleX(-1) rotate(180deg);-moz-transform:scaleX(-1) rotate(180deg);-ms-transform:scaleX(-1) rotate(180deg);-o-transform:scaleX(-1) rotate(180deg);transform:scaleX(-1) rotate(180deg)}.mirror.rotate-270{-webkit-transform:scaleX(-1) rotate(270deg);-moz-transform:scaleX(-1) rotate(270deg);-ms-transform:scaleX(-1) rotate(270deg);-o-transform:scaleX(-1) rotate(270deg);transform:scaleX(-1) rotate(270deg)}@media only screen and (max-width:480px){.wy-form button[type=submit]{margin:.7em 0 0}.wy-form input[type=color],.wy-form input[type=date],.wy-form input[type=datetime-local],.wy-form input[type=datetime],.wy-form input[type=email],.wy-form input[type=month],.wy-form input[type=number],.wy-form input[type=password],.wy-form input[type=search],.wy-form input[type=tel],.wy-form input[type=text],.wy-form input[type=time],.wy-form input[type=url],.wy-form input[type=week],.wy-form label{margin-bottom:.3em;display:block}.wy-form input[type=color],.wy-form input[type=date],.wy-form input[type=datetime-local],.wy-form input[type=datetime],.wy-form input[type=email],.wy-form input[type=month],.wy-form input[type=number],.wy-form input[type=password],.wy-form input[type=search],.wy-form input[type=tel],.wy-form input[type=time],.wy-form input[type=url],.wy-form input[type=week]{margin-bottom:0}.wy-form-aligned .wy-control-group label{margin-bottom:.3em;text-align:left;display:block;width:100%}.wy-form-aligned .wy-control{margin:1.5em 0 0}.wy-form-message,.wy-form-message-inline,.wy-form .wy-help-inline{display:block;font-size:80%;padding:6px 0}}@media screen and (max-width:768px){.tablet-hide{display:none}}@media screen and (max-width:480px){.mobile-hide{display:none}}.float-left{float:left}.float-right{float:right}.full-width{width:100%}.rst-content table.docutils,.rst-content table.field-list,.wy-table{border-collapse:collapse;border-spacing:0;empty-cells:show;margin-bottom:24px}.rst-content table.docutils caption,.rst-content table.field-list caption,.wy-table caption{color:#000;font:italic 85%/1 arial,sans-serif;padding:1em 0;text-align:center}.rst-content table.docutils td,.rst-content table.docutils th,.rst-content table.field-list td,.rst-content table.field-list th,.wy-table td,.wy-table th{font-size:90%;margin:0;overflow:visible;padding:8px 16px}.rst-content table.docutils td:first-child,.rst-content table.docutils th:first-child,.rst-content table.field-list td:first-child,.rst-content table.field-list th:first-child,.wy-table td:first-child,.wy-table th:first-child{border-left-width:0}.rst-content table.docutils thead,.rst-content table.field-list thead,.wy-table thead{color:#000;text-align:left;vertical-align:bottom;white-space:nowrap}.rst-content table.docutils thead th,.rst-content table.field-list thead th,.wy-table thead th{font-weight:700;border-bottom:2px solid #e1e4e5}.rst-content table.docutils td,.rst-content table.field-list td,.wy-table td{background-color:transparent;vertical-align:middle}.rst-content table.docutils td p,.rst-content table.field-list td p,.wy-table td p{line-height:18px}.rst-content table.docutils td p:last-child,.rst-content table.field-list td p:last-child,.wy-table td p:last-child{margin-bottom:0}.rst-content table.docutils .wy-table-cell-min,.rst-content table.field-list .wy-table-cell-min,.wy-table .wy-table-cell-min{width:1%;padding-right:0}.rst-content table.docutils .wy-table-cell-min input[type=checkbox],.rst-content table.field-list .wy-table-cell-min input[type=checkbox],.wy-table .wy-table-cell-min input[type=checkbox]{margin:0}.wy-table-secondary{color:grey;font-size:90%}.wy-table-tertiary{color:grey;font-size:80%}.rst-content table.docutils:not(.field-list) tr:nth-child(2n-1) td,.wy-table-backed,.wy-table-odd td,.wy-table-striped tr:nth-child(2n-1) td{background-color:#f3f6f6}.rst-content table.docutils,.wy-table-bordered-all{border:1px solid #e1e4e5}.rst-content table.docutils td,.wy-table-bordered-all td{border-bottom:1px solid #e1e4e5;border-left:1px solid #e1e4e5}.rst-content table.docutils tbody>tr:last-child td,.wy-table-bordered-all tbody>tr:last-child td{border-bottom-width:0}.wy-table-bordered{border:1px solid #e1e4e5}.wy-table-bordered-rows td{border-bottom:1px solid #e1e4e5}.wy-table-bordered-rows tbody>tr:last-child td{border-bottom-width:0}.wy-table-horizontal td,.wy-table-horizontal th{border-width:0 0 1px;border-bottom:1px solid #e1e4e5}.wy-table-horizontal tbody>tr:last-child td{border-bottom-width:0}.wy-table-responsive{margin-bottom:24px;max-width:100%;overflow:auto}.wy-table-responsive table{margin-bottom:0!important}.wy-table-responsive table td,.wy-table-responsive table th{white-space:nowrap}a{color:#2980b9;text-decoration:none;cursor:pointer}a:hover{color:#3091d1}a:visited{color:#9b59b6}html{height:100%}body,html{overflow-x:hidden}body{font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;font-weight:400;color:#404040;min-height:100%;background:#edf0f2}.wy-text-left{text-align:left}.wy-text-center{text-align:center}.wy-text-right{text-align:right}.wy-text-large{font-size:120%}.wy-text-normal{font-size:100%}.wy-text-small,small{font-size:80%}.wy-text-strike{text-decoration:line-through}.wy-text-warning{color:#e67e22!important}a.wy-text-warning:hover{color:#eb9950!important}.wy-text-info{color:#2980b9!important}a.wy-text-info:hover{color:#409ad5!important}.wy-text-success{color:#27ae60!important}a.wy-text-success:hover{color:#36d278!important}.wy-text-danger{color:#e74c3c!important}a.wy-text-danger:hover{color:#ed7669!important}.wy-text-neutral{color:#404040!important}a.wy-text-neutral:hover{color:#595959!important}.rst-content .toctree-wrapper>p.caption,h1,h2,h3,h4,h5,h6,legend{margin-top:0;font-weight:700;font-family:Roboto Slab,ff-tisa-web-pro,Georgia,Arial,sans-serif}p{line-height:24px;font-size:16px;margin:0 0 24px}h1{font-size:175%}.rst-content .toctree-wrapper>p.caption,h2{font-size:150%}h3{font-size:125%}h4{font-size:115%}h5{font-size:110%}h6{font-size:100%}hr{display:block;height:1px;border:0;border-top:1px solid #e1e4e5;margin:24px 0;padding:0}.rst-content code,.rst-content tt,code{white-space:nowrap;max-width:100%;background:#fff;border:1px solid #e1e4e5;font-size:75%;padding:0 5px;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;color:#e74c3c;overflow-x:auto}.rst-content tt.code-large,code.code-large{font-size:90%}.rst-content .section ul,.rst-content .toctree-wrapper ul,.rst-content section ul,.wy-plain-list-disc,article ul{list-style:disc;line-height:24px;margin-bottom:24px}.rst-content .section ul li,.rst-content .toctree-wrapper ul li,.rst-content section ul li,.wy-plain-list-disc li,article ul li{list-style:disc;margin-left:24px}.rst-content .section ul li p:last-child,.rst-content .section ul li ul,.rst-content .toctree-wrapper ul li p:last-child,.rst-content .toctree-wrapper ul li ul,.rst-content section ul li p:last-child,.rst-content section ul li ul,.wy-plain-list-disc li p:last-child,.wy-plain-list-disc li ul,article ul li p:last-child,article ul li ul{margin-bottom:0}.rst-content .section ul li li,.rst-content .toctree-wrapper ul li li,.rst-content section ul li li,.wy-plain-list-disc li li,article ul li li{list-style:circle}.rst-content .section ul li li li,.rst-content .toctree-wrapper ul li li li,.rst-content section ul li li li,.wy-plain-list-disc li li li,article ul li li li{list-style:square}.rst-content .section ul li ol li,.rst-content .toctree-wrapper ul li ol li,.rst-content section ul li ol li,.wy-plain-list-disc li ol li,article ul li ol li{list-style:decimal}.rst-content .section ol,.rst-content .section ol.arabic,.rst-content .toctree-wrapper ol,.rst-content .toctree-wrapper ol.arabic,.rst-content section ol,.rst-content section ol.arabic,.wy-plain-list-decimal,article ol{list-style:decimal;line-height:24px;margin-bottom:24px}.rst-content .section ol.arabic li,.rst-content .section ol li,.rst-content .toctree-wrapper ol.arabic li,.rst-content .toctree-wrapper ol li,.rst-content section ol.arabic li,.rst-content section ol li,.wy-plain-list-decimal li,article ol li{list-style:decimal;margin-left:24px}.rst-content .section ol.arabic li ul,.rst-content .section ol li p:last-child,.rst-content .section ol li ul,.rst-content .toctree-wrapper ol.arabic li ul,.rst-content .toctree-wrapper ol li p:last-child,.rst-content .toctree-wrapper ol li ul,.rst-content section ol.arabic li ul,.rst-content section ol li p:last-child,.rst-content section ol li ul,.wy-plain-list-decimal li p:last-child,.wy-plain-list-decimal li ul,article ol li p:last-child,article ol li ul{margin-bottom:0}.rst-content .section ol.arabic li ul li,.rst-content .section ol li ul li,.rst-content .toctree-wrapper ol.arabic li ul li,.rst-content .toctree-wrapper ol li ul li,.rst-content section ol.arabic li ul li,.rst-content section ol li ul li,.wy-plain-list-decimal li ul li,article ol li ul li{list-style:disc}.wy-breadcrumbs{*zoom:1}.wy-breadcrumbs:after,.wy-breadcrumbs:before{display:table;content:""}.wy-breadcrumbs:after{clear:both}.wy-breadcrumbs>li{display:inline-block;padding-top:5px}.wy-breadcrumbs>li.wy-breadcrumbs-aside{float:right}.rst-content .wy-breadcrumbs>li code,.rst-content .wy-breadcrumbs>li tt,.wy-breadcrumbs>li .rst-content tt,.wy-breadcrumbs>li code{all:inherit;color:inherit}.breadcrumb-item:before{content:"/";color:#bbb;font-size:13px;padding:0 6px 0 3px}.wy-breadcrumbs-extra{margin-bottom:0;color:#b3b3b3;font-size:80%;display:inline-block}@media screen and (max-width:480px){.wy-breadcrumbs-extra,.wy-breadcrumbs li.wy-breadcrumbs-aside{display:none}}@media print{.wy-breadcrumbs li.wy-breadcrumbs-aside{display:none}}html{font-size:16px}.wy-affix{position:fixed;top:1.618em}.wy-menu a:hover{text-decoration:none}.wy-menu-horiz{*zoom:1}.wy-menu-horiz:after,.wy-menu-horiz:before{display:table;content:""}.wy-menu-horiz:after{clear:both}.wy-menu-horiz li,.wy-menu-horiz ul{display:inline-block}.wy-menu-horiz li:hover{background:hsla(0,0%,100%,.1)}.wy-menu-horiz li.divide-left{border-left:1px solid #404040}.wy-menu-horiz li.divide-right{border-right:1px solid #404040}.wy-menu-horiz a{height:32px;display:inline-block;line-height:32px;padding:0 16px}.wy-menu-vertical{width:300px}.wy-menu-vertical header,.wy-menu-vertical p.caption{color:#55a5d9;height:32px;line-height:32px;padding:0 1.618em;margin:12px 0 0;display:block;font-weight:700;text-transform:uppercase;font-size:85%;white-space:nowrap}.wy-menu-vertical ul{margin-bottom:0}.wy-menu-vertical li.divide-top{border-top:1px solid #404040}.wy-menu-vertical li.divide-bottom{border-bottom:1px solid #404040}.wy-menu-vertical li.current{background:#e3e3e3}.wy-menu-vertical li.current a{color:grey;border-right:1px solid #c9c9c9;padding:.4045em 2.427em}.wy-menu-vertical li.current a:hover{background:#d6d6d6}.rst-content .wy-menu-vertical li tt,.wy-menu-vertical li .rst-content tt,.wy-menu-vertical li code{border:none;background:inherit;color:inherit;padding-left:0;padding-right:0}.wy-menu-vertical li button.toctree-expand{display:block;float:left;margin-left:-1.2em;line-height:18px;color:#4d4d4d;border:none;background:none;padding:0}.wy-menu-vertical li.current>a,.wy-menu-vertical li.on a{color:#404040;font-weight:700;position:relative;background:#fcfcfc;border:none;padding:.4045em 1.618em}.wy-menu-vertical li.current>a:hover,.wy-menu-vertical li.on a:hover{background:#fcfcfc}.wy-menu-vertical li.current>a:hover button.toctree-expand,.wy-menu-vertical li.on a:hover button.toctree-expand{color:grey}.wy-menu-vertical li.current>a button.toctree-expand,.wy-menu-vertical li.on a button.toctree-expand{display:block;line-height:18px;color:#333}.wy-menu-vertical li.toctree-l1.current>a{border-bottom:1px solid #c9c9c9;border-top:1px solid #c9c9c9}.wy-menu-vertical .toctree-l1.current .toctree-l2>ul,.wy-menu-vertical .toctree-l2.current .toctree-l3>ul,.wy-menu-vertical .toctree-l3.current .toctree-l4>ul,.wy-menu-vertical .toctree-l4.current .toctree-l5>ul,.wy-menu-vertical .toctree-l5.current .toctree-l6>ul,.wy-menu-vertical .toctree-l6.current .toctree-l7>ul,.wy-menu-vertical .toctree-l7.current .toctree-l8>ul,.wy-menu-vertical .toctree-l8.current .toctree-l9>ul,.wy-menu-vertical .toctree-l9.current .toctree-l10>ul,.wy-menu-vertical .toctree-l10.current .toctree-l11>ul{display:none}.wy-menu-vertical .toctree-l1.current .current.toctree-l2>ul,.wy-menu-vertical .toctree-l2.current .current.toctree-l3>ul,.wy-menu-vertical .toctree-l3.current .current.toctree-l4>ul,.wy-menu-vertical .toctree-l4.current .current.toctree-l5>ul,.wy-menu-vertical .toctree-l5.current .current.toctree-l6>ul,.wy-menu-vertical .toctree-l6.current .current.toctree-l7>ul,.wy-menu-vertical .toctree-l7.current .current.toctree-l8>ul,.wy-menu-vertical .toctree-l8.current .current.toctree-l9>ul,.wy-menu-vertical .toctree-l9.current .current.toctree-l10>ul,.wy-menu-vertical .toctree-l10.current .current.toctree-l11>ul{display:block}.wy-menu-vertical li.toctree-l3,.wy-menu-vertical li.toctree-l4{font-size:.9em}.wy-menu-vertical li.toctree-l2 a,.wy-menu-vertical li.toctree-l3 a,.wy-menu-vertical li.toctree-l4 a,.wy-menu-vertical li.toctree-l5 a,.wy-menu-vertical li.toctree-l6 a,.wy-menu-vertical li.toctree-l7 a,.wy-menu-vertical li.toctree-l8 a,.wy-menu-vertical li.toctree-l9 a,.wy-menu-vertical li.toctree-l10 a{color:#404040}.wy-menu-vertical li.toctree-l2 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l3 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l4 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l5 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l6 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l7 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l8 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l9 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l10 a:hover button.toctree-expand{color:grey}.wy-menu-vertical li.toctree-l2.current li.toctree-l3>a,.wy-menu-vertical li.toctree-l3.current li.toctree-l4>a,.wy-menu-vertical li.toctree-l4.current li.toctree-l5>a,.wy-menu-vertical li.toctree-l5.current li.toctree-l6>a,.wy-menu-vertical li.toctree-l6.current li.toctree-l7>a,.wy-menu-vertical li.toctree-l7.current li.toctree-l8>a,.wy-menu-vertical li.toctree-l8.current li.toctree-l9>a,.wy-menu-vertical li.toctree-l9.current li.toctree-l10>a,.wy-menu-vertical li.toctree-l10.current li.toctree-l11>a{display:block}.wy-menu-vertical li.toctree-l2.current>a{padding:.4045em 2.427em}.wy-menu-vertical li.toctree-l2.current li.toctree-l3>a{padding:.4045em 1.618em .4045em 4.045em}.wy-menu-vertical li.toctree-l3.current>a{padding:.4045em 4.045em}.wy-menu-vertical li.toctree-l3.current li.toctree-l4>a{padding:.4045em 1.618em .4045em 5.663em}.wy-menu-vertical li.toctree-l4.current>a{padding:.4045em 5.663em}.wy-menu-vertical li.toctree-l4.current li.toctree-l5>a{padding:.4045em 1.618em .4045em 7.281em}.wy-menu-vertical li.toctree-l5.current>a{padding:.4045em 7.281em}.wy-menu-vertical li.toctree-l5.current li.toctree-l6>a{padding:.4045em 1.618em .4045em 8.899em}.wy-menu-vertical li.toctree-l6.current>a{padding:.4045em 8.899em}.wy-menu-vertical li.toctree-l6.current li.toctree-l7>a{padding:.4045em 1.618em .4045em 10.517em}.wy-menu-vertical li.toctree-l7.current>a{padding:.4045em 10.517em}.wy-menu-vertical li.toctree-l7.current li.toctree-l8>a{padding:.4045em 1.618em .4045em 12.135em}.wy-menu-vertical li.toctree-l8.current>a{padding:.4045em 12.135em}.wy-menu-vertical li.toctree-l8.current li.toctree-l9>a{padding:.4045em 1.618em .4045em 13.753em}.wy-menu-vertical li.toctree-l9.current>a{padding:.4045em 13.753em}.wy-menu-vertical li.toctree-l9.current li.toctree-l10>a{padding:.4045em 1.618em .4045em 15.371em}.wy-menu-vertical li.toctree-l10.current>a{padding:.4045em 15.371em}.wy-menu-vertical li.toctree-l10.current li.toctree-l11>a{padding:.4045em 1.618em .4045em 16.989em}.wy-menu-vertical li.toctree-l2.current>a,.wy-menu-vertical li.toctree-l2.current li.toctree-l3>a{background:#c9c9c9}.wy-menu-vertical li.toctree-l2 button.toctree-expand{color:#a3a3a3}.wy-menu-vertical li.toctree-l3.current>a,.wy-menu-vertical li.toctree-l3.current li.toctree-l4>a{background:#bdbdbd}.wy-menu-vertical li.toctree-l3 button.toctree-expand{color:#969696}.wy-menu-vertical li.current ul{display:block}.wy-menu-vertical li ul{margin-bottom:0;display:none}.wy-menu-vertical li ul li a{margin-bottom:0;color:#d9d9d9;font-weight:400}.wy-menu-vertical a{line-height:18px;padding:.4045em 1.618em;display:block;position:relative;font-size:90%;color:#d9d9d9}.wy-menu-vertical a:hover{background-color:#4e4a4a;cursor:pointer}.wy-menu-vertical a:hover button.toctree-expand{color:#d9d9d9}.wy-menu-vertical a:active{background-color:#2980b9;cursor:pointer;color:#fff}.wy-menu-vertical a:active button.toctree-expand{color:#fff}.wy-side-nav-search{display:block;width:300px;padding:.809em;margin-bottom:.809em;z-index:200;background-color:#2980b9;text-align:center;color:#fcfcfc}.wy-side-nav-search input[type=text]{width:100%;border-radius:50px;padding:6px 12px;border-color:#2472a4}.wy-side-nav-search img{display:block;margin:auto auto .809em;height:45px;width:45px;background-color:#2980b9;padding:5px;border-radius:100%}.wy-side-nav-search .wy-dropdown>a,.wy-side-nav-search>a{color:#fcfcfc;font-size:100%;font-weight:700;display:inline-block;padding:4px 6px;margin-bottom:.809em;max-width:100%}.wy-side-nav-search .wy-dropdown>a:hover,.wy-side-nav-search>a:hover{background:hsla(0,0%,100%,.1)}.wy-side-nav-search .wy-dropdown>a img.logo,.wy-side-nav-search>a img.logo{display:block;margin:0 auto;height:auto;width:auto;border-radius:0;max-width:100%;background:transparent}.wy-side-nav-search .wy-dropdown>a.icon img.logo,.wy-side-nav-search>a.icon img.logo{margin-top:.85em}.wy-side-nav-search>div.version{margin-top:-.4045em;margin-bottom:.809em;font-weight:400;color:hsla(0,0%,100%,.3)}.wy-nav .wy-menu-vertical header{color:#2980b9}.wy-nav .wy-menu-vertical a{color:#b3b3b3}.wy-nav .wy-menu-vertical a:hover{background-color:#2980b9;color:#fff}[data-menu-wrap]{-webkit-transition:all .2s ease-in;-moz-transition:all .2s ease-in;transition:all .2s ease-in;position:absolute;opacity:1;width:100%;opacity:0}[data-menu-wrap].move-center{left:0;right:auto;opacity:1}[data-menu-wrap].move-left{right:auto;left:-100%;opacity:0}[data-menu-wrap].move-right{right:-100%;left:auto;opacity:0}.wy-body-for-nav{background:#fcfcfc}.wy-grid-for-nav{position:absolute;width:100%;height:100%}.wy-nav-side{position:fixed;top:0;bottom:0;left:0;padding-bottom:2em;width:300px;overflow-x:hidden;overflow-y:hidden;min-height:100%;color:#9b9b9b;background:#343131;z-index:200}.wy-side-scroll{width:320px;position:relative;overflow-x:hidden;overflow-y:scroll;height:100%}.wy-nav-top{display:none;background:#2980b9;color:#fff;padding:.4045em .809em;position:relative;line-height:50px;text-align:center;font-size:100%;*zoom:1}.wy-nav-top:after,.wy-nav-top:before{display:table;content:""}.wy-nav-top:after{clear:both}.wy-nav-top a{color:#fff;font-weight:700}.wy-nav-top img{margin-right:12px;height:45px;width:45px;background-color:#2980b9;padding:5px;border-radius:100%}.wy-nav-top i{font-size:30px;float:left;cursor:pointer;padding-top:inherit}.wy-nav-content-wrap{margin-left:300px;background:#fcfcfc;min-height:100%}.wy-nav-content{padding:1.618em 3.236em;height:100%;max-width:800px;margin:auto}.wy-body-mask{position:fixed;width:100%;height:100%;background:rgba(0,0,0,.2);display:none;z-index:499}.wy-body-mask.on{display:block}footer{color:grey}footer p{margin-bottom:12px}.rst-content footer span.commit tt,footer span.commit .rst-content tt,footer span.commit code{padding:0;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;font-size:1em;background:none;border:none;color:grey}.rst-footer-buttons{*zoom:1}.rst-footer-buttons:after,.rst-footer-buttons:before{width:100%;display:table;content:""}.rst-footer-buttons:after{clear:both}.rst-breadcrumbs-buttons{margin-top:12px;*zoom:1}.rst-breadcrumbs-buttons:after,.rst-breadcrumbs-buttons:before{display:table;content:""}.rst-breadcrumbs-buttons:after{clear:both}#search-results .search li{margin-bottom:24px;border-bottom:1px solid #e1e4e5;padding-bottom:24px}#search-results .search li:first-child{border-top:1px solid #e1e4e5;padding-top:24px}#search-results .search li a{font-size:120%;margin-bottom:12px;display:inline-block}#search-results .context{color:grey;font-size:90%}.genindextable li>ul{margin-left:24px}@media screen and (max-width:768px){.wy-body-for-nav{background:#fcfcfc}.wy-nav-top{display:block}.wy-nav-side{left:-300px}.wy-nav-side.shift{width:85%;left:0}.wy-menu.wy-menu-vertical,.wy-side-nav-search,.wy-side-scroll{width:auto}.wy-nav-content-wrap{margin-left:0}.wy-nav-content-wrap .wy-nav-content{padding:1.618em}.wy-nav-content-wrap.shift{position:fixed;min-width:100%;left:85%;top:0;height:100%;overflow:hidden}}@media screen and (min-width:1100px){.wy-nav-content-wrap{background:rgba(0,0,0,.05)}.wy-nav-content{margin:0;background:#fcfcfc}}@media print{.rst-versions,.wy-nav-side,footer{display:none}.wy-nav-content-wrap{margin-left:0}}.rst-versions{position:fixed;bottom:0;left:0;width:300px;color:#fcfcfc;background:#1f1d1d;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;z-index:400}.rst-versions a{color:#2980b9;text-decoration:none}.rst-versions .rst-badge-small{display:none}.rst-versions .rst-current-version{padding:12px;background-color:#272525;display:block;text-align:right;font-size:90%;cursor:pointer;color:#27ae60;*zoom:1}.rst-versions .rst-current-version:after,.rst-versions .rst-current-version:before{display:table;content:""}.rst-versions .rst-current-version:after{clear:both}.rst-content .code-block-caption .rst-versions .rst-current-version .headerlink,.rst-content .eqno .rst-versions .rst-current-version .headerlink,.rst-content .rst-versions .rst-current-version .admonition-title,.rst-content code.download .rst-versions .rst-current-version span:first-child,.rst-content dl dt .rst-versions .rst-current-version .headerlink,.rst-content h1 .rst-versions .rst-current-version .headerlink,.rst-content h2 .rst-versions .rst-current-version .headerlink,.rst-content h3 .rst-versions .rst-current-version .headerlink,.rst-content h4 .rst-versions .rst-current-version .headerlink,.rst-content h5 .rst-versions .rst-current-version .headerlink,.rst-content h6 .rst-versions .rst-current-version .headerlink,.rst-content p .rst-versions .rst-current-version .headerlink,.rst-content table>caption .rst-versions .rst-current-version .headerlink,.rst-content tt.download .rst-versions .rst-current-version span:first-child,.rst-versions .rst-current-version .fa,.rst-versions .rst-current-version .icon,.rst-versions .rst-current-version .rst-content .admonition-title,.rst-versions .rst-current-version .rst-content .code-block-caption .headerlink,.rst-versions .rst-current-version .rst-content .eqno .headerlink,.rst-versions .rst-current-version .rst-content code.download span:first-child,.rst-versions .rst-current-version .rst-content dl dt .headerlink,.rst-versions .rst-current-version .rst-content h1 .headerlink,.rst-versions .rst-current-version .rst-content h2 .headerlink,.rst-versions .rst-current-version .rst-content h3 .headerlink,.rst-versions .rst-current-version .rst-content h4 .headerlink,.rst-versions .rst-current-version .rst-content h5 .headerlink,.rst-versions .rst-current-version .rst-content h6 .headerlink,.rst-versions .rst-current-version .rst-content p .headerlink,.rst-versions .rst-current-version .rst-content table>caption .headerlink,.rst-versions .rst-current-version .rst-content tt.download span:first-child,.rst-versions .rst-current-version .wy-menu-vertical li button.toctree-expand,.wy-menu-vertical li .rst-versions .rst-current-version button.toctree-expand{color:#fcfcfc}.rst-versions .rst-current-version .fa-book,.rst-versions .rst-current-version .icon-book{float:left}.rst-versions .rst-current-version.rst-out-of-date{background-color:#e74c3c;color:#fff}.rst-versions .rst-current-version.rst-active-old-version{background-color:#f1c40f;color:#000}.rst-versions.shift-up{height:auto;max-height:100%;overflow-y:scroll}.rst-versions.shift-up .rst-other-versions{display:block}.rst-versions .rst-other-versions{font-size:90%;padding:12px;color:grey;display:none}.rst-versions .rst-other-versions hr{display:block;height:1px;border:0;margin:20px 0;padding:0;border-top:1px solid #413d3d}.rst-versions .rst-other-versions dd{display:inline-block;margin:0}.rst-versions .rst-other-versions dd a{display:inline-block;padding:6px;color:#fcfcfc}.rst-versions.rst-badge{width:auto;bottom:20px;right:20px;left:auto;border:none;max-width:300px;max-height:90%}.rst-versions.rst-badge .fa-book,.rst-versions.rst-badge .icon-book{float:none;line-height:30px}.rst-versions.rst-badge.shift-up .rst-current-version{text-align:right}.rst-versions.rst-badge.shift-up .rst-current-version .fa-book,.rst-versions.rst-badge.shift-up .rst-current-version .icon-book{float:left}.rst-versions.rst-badge>.rst-current-version{width:auto;height:30px;line-height:30px;padding:0 6px;display:block;text-align:center}@media screen and (max-width:768px){.rst-versions{width:85%;display:none}.rst-versions.shift{display:block}}.rst-content .toctree-wrapper>p.caption,.rst-content h1,.rst-content h2,.rst-content h3,.rst-content h4,.rst-content h5,.rst-content h6{margin-bottom:24px}.rst-content img{max-width:100%;height:auto}.rst-content div.figure,.rst-content figure{margin-bottom:24px}.rst-content div.figure .caption-text,.rst-content figure .caption-text{font-style:italic}.rst-content div.figure p:last-child.caption,.rst-content figure p:last-child.caption{margin-bottom:0}.rst-content div.figure.align-center,.rst-content figure.align-center{text-align:center}.rst-content .section>a>img,.rst-content .section>img,.rst-content section>a>img,.rst-content section>img{margin-bottom:24px}.rst-content abbr[title]{text-decoration:none}.rst-content.style-external-links a.reference.external:after{font-family:FontAwesome;content:"\f08e";color:#b3b3b3;vertical-align:super;font-size:60%;margin:0 .2em}.rst-content blockquote{margin-left:24px;line-height:24px;margin-bottom:24px}.rst-content pre.literal-block{white-space:pre;margin:0;padding:12px;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;display:block;overflow:auto}.rst-content div[class^=highlight],.rst-content pre.literal-block{border:1px solid #e1e4e5;overflow-x:auto;margin:1px 0 24px}.rst-content div[class^=highlight] div[class^=highlight],.rst-content pre.literal-block div[class^=highlight]{padding:0;border:none;margin:0}.rst-content div[class^=highlight] td.code{width:100%}.rst-content .linenodiv pre{border-right:1px solid #e6e9ea;margin:0;padding:12px;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;user-select:none;pointer-events:none}.rst-content div[class^=highlight] pre{white-space:pre;margin:0;padding:12px;display:block;overflow:auto}.rst-content div[class^=highlight] pre .hll{display:block;margin:0 -12px;padding:0 12px}.rst-content .linenodiv pre,.rst-content div[class^=highlight] pre,.rst-content pre.literal-block{font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;font-size:12px;line-height:1.4}.rst-content div.highlight .gp,.rst-content div.highlight span.linenos{user-select:none;pointer-events:none}.rst-content div.highlight span.linenos{display:inline-block;padding-left:0;padding-right:12px;margin-right:12px;border-right:1px solid #e6e9ea}.rst-content .code-block-caption{font-style:italic;font-size:85%;line-height:1;padding:1em 0;text-align:center}@media print{.rst-content .codeblock,.rst-content div[class^=highlight],.rst-content div[class^=highlight] pre{white-space:pre-wrap}}.rst-content .admonition,.rst-content .admonition-todo,.rst-content .attention,.rst-content .caution,.rst-content .danger,.rst-content .error,.rst-content .hint,.rst-content .important,.rst-content .note,.rst-content .seealso,.rst-content .tip,.rst-content .warning{clear:both}.rst-content .admonition-todo .last,.rst-content .admonition-todo>:last-child,.rst-content .admonition .last,.rst-content .admonition>:last-child,.rst-content .attention .last,.rst-content .attention>:last-child,.rst-content .caution .last,.rst-content .caution>:last-child,.rst-content .danger .last,.rst-content .danger>:last-child,.rst-content .error .last,.rst-content .error>:last-child,.rst-content .hint .last,.rst-content .hint>:last-child,.rst-content .important .last,.rst-content .important>:last-child,.rst-content .note .last,.rst-content .note>:last-child,.rst-content .seealso .last,.rst-content .seealso>:last-child,.rst-content .tip .last,.rst-content .tip>:last-child,.rst-content .warning .last,.rst-content .warning>:last-child{margin-bottom:0}.rst-content .admonition-title:before{margin-right:4px}.rst-content .admonition table{border-color:rgba(0,0,0,.1)}.rst-content .admonition table td,.rst-content .admonition table th{background:transparent!important;border-color:rgba(0,0,0,.1)!important}.rst-content .section ol.loweralpha,.rst-content .section ol.loweralpha>li,.rst-content .toctree-wrapper ol.loweralpha,.rst-content .toctree-wrapper ol.loweralpha>li,.rst-content section ol.loweralpha,.rst-content section ol.loweralpha>li{list-style:lower-alpha}.rst-content .section ol.upperalpha,.rst-content .section ol.upperalpha>li,.rst-content .toctree-wrapper ol.upperalpha,.rst-content .toctree-wrapper ol.upperalpha>li,.rst-content section ol.upperalpha,.rst-content section ol.upperalpha>li{list-style:upper-alpha}.rst-content .section ol li>*,.rst-content .section ul li>*,.rst-content .toctree-wrapper ol li>*,.rst-content .toctree-wrapper ul li>*,.rst-content section ol li>*,.rst-content section ul li>*{margin-top:12px;margin-bottom:12px}.rst-content .section ol li>:first-child,.rst-content .section ul li>:first-child,.rst-content .toctree-wrapper ol li>:first-child,.rst-content .toctree-wrapper ul li>:first-child,.rst-content section ol li>:first-child,.rst-content section ul li>:first-child{margin-top:0}.rst-content .section ol li>p,.rst-content .section ol li>p:last-child,.rst-content .section ul li>p,.rst-content .section ul li>p:last-child,.rst-content .toctree-wrapper ol li>p,.rst-content .toctree-wrapper ol li>p:last-child,.rst-content .toctree-wrapper ul li>p,.rst-content .toctree-wrapper ul li>p:last-child,.rst-content section ol li>p,.rst-content section ol li>p:last-child,.rst-content section ul li>p,.rst-content section ul li>p:last-child{margin-bottom:12px}.rst-content .section ol li>p:only-child,.rst-content .section ol li>p:only-child:last-child,.rst-content .section ul li>p:only-child,.rst-content .section ul li>p:only-child:last-child,.rst-content .toctree-wrapper ol li>p:only-child,.rst-content .toctree-wrapper ol li>p:only-child:last-child,.rst-content .toctree-wrapper ul li>p:only-child,.rst-content .toctree-wrapper ul li>p:only-child:last-child,.rst-content section ol li>p:only-child,.rst-content section ol li>p:only-child:last-child,.rst-content section ul li>p:only-child,.rst-content section ul li>p:only-child:last-child{margin-bottom:0}.rst-content .section ol li>ol,.rst-content .section ol li>ul,.rst-content .section ul li>ol,.rst-content .section ul li>ul,.rst-content .toctree-wrapper ol li>ol,.rst-content .toctree-wrapper ol li>ul,.rst-content .toctree-wrapper ul li>ol,.rst-content .toctree-wrapper ul li>ul,.rst-content section ol li>ol,.rst-content section ol li>ul,.rst-content section ul li>ol,.rst-content section ul li>ul{margin-bottom:12px}.rst-content .section ol.simple li>*,.rst-content .section ol.simple li ol,.rst-content .section ol.simple li ul,.rst-content .section ul.simple li>*,.rst-content .section ul.simple li ol,.rst-content .section ul.simple li ul,.rst-content .toctree-wrapper ol.simple li>*,.rst-content .toctree-wrapper ol.simple li ol,.rst-content .toctree-wrapper ol.simple li ul,.rst-content .toctree-wrapper ul.simple li>*,.rst-content .toctree-wrapper ul.simple li ol,.rst-content .toctree-wrapper ul.simple li ul,.rst-content section ol.simple li>*,.rst-content section ol.simple li ol,.rst-content section ol.simple li ul,.rst-content section ul.simple li>*,.rst-content section ul.simple li ol,.rst-content section ul.simple li ul{margin-top:0;margin-bottom:0}.rst-content .line-block{margin-left:0;margin-bottom:24px;line-height:24px}.rst-content .line-block .line-block{margin-left:24px;margin-bottom:0}.rst-content .topic-title{font-weight:700;margin-bottom:12px}.rst-content .toc-backref{color:#404040}.rst-content .align-right{float:right;margin:0 0 24px 24px}.rst-content .align-left{float:left;margin:0 24px 24px 0}.rst-content .align-center{margin:auto}.rst-content .align-center:not(table){display:block}.rst-content .code-block-caption .headerlink,.rst-content .eqno .headerlink,.rst-content .toctree-wrapper>p.caption .headerlink,.rst-content dl dt .headerlink,.rst-content h1 .headerlink,.rst-content h2 .headerlink,.rst-content h3 .headerlink,.rst-content h4 .headerlink,.rst-content h5 .headerlink,.rst-content h6 .headerlink,.rst-content p.caption .headerlink,.rst-content p .headerlink,.rst-content table>caption .headerlink{opacity:0;font-size:14px;font-family:FontAwesome;margin-left:.5em}.rst-content .code-block-caption .headerlink:focus,.rst-content .code-block-caption:hover .headerlink,.rst-content .eqno .headerlink:focus,.rst-content .eqno:hover .headerlink,.rst-content .toctree-wrapper>p.caption .headerlink:focus,.rst-content .toctree-wrapper>p.caption:hover .headerlink,.rst-content dl dt .headerlink:focus,.rst-content dl dt:hover .headerlink,.rst-content h1 .headerlink:focus,.rst-content h1:hover .headerlink,.rst-content h2 .headerlink:focus,.rst-content h2:hover .headerlink,.rst-content h3 .headerlink:focus,.rst-content h3:hover .headerlink,.rst-content h4 .headerlink:focus,.rst-content h4:hover .headerlink,.rst-content h5 .headerlink:focus,.rst-content h5:hover .headerlink,.rst-content h6 .headerlink:focus,.rst-content h6:hover .headerlink,.rst-content p.caption .headerlink:focus,.rst-content p.caption:hover .headerlink,.rst-content p .headerlink:focus,.rst-content p:hover .headerlink,.rst-content table>caption .headerlink:focus,.rst-content table>caption:hover .headerlink{opacity:1}.rst-content p a{overflow-wrap:anywhere}.rst-content .wy-table td p,.rst-content .wy-table td ul,.rst-content .wy-table th p,.rst-content .wy-table th ul,.rst-content table.docutils td p,.rst-content table.docutils td ul,.rst-content table.docutils th p,.rst-content table.docutils th ul,.rst-content table.field-list td p,.rst-content table.field-list td ul,.rst-content table.field-list th p,.rst-content table.field-list th ul{font-size:inherit}.rst-content .btn:focus{outline:2px solid}.rst-content table>caption .headerlink:after{font-size:12px}.rst-content .centered{text-align:center}.rst-content .sidebar{float:right;width:40%;display:block;margin:0 0 24px 24px;padding:24px;background:#f3f6f6;border:1px solid #e1e4e5}.rst-content .sidebar dl,.rst-content .sidebar p,.rst-content .sidebar ul{font-size:90%}.rst-content .sidebar .last,.rst-content .sidebar>:last-child{margin-bottom:0}.rst-content .sidebar .sidebar-title{display:block;font-family:Roboto Slab,ff-tisa-web-pro,Georgia,Arial,sans-serif;font-weight:700;background:#e1e4e5;padding:6px 12px;margin:-24px -24px 24px;font-size:100%}.rst-content .highlighted{background:#f1c40f;box-shadow:0 0 0 2px #f1c40f;display:inline;font-weight:700}.rst-content .citation-reference,.rst-content .footnote-reference{vertical-align:baseline;position:relative;top:-.4em;line-height:0;font-size:90%}.rst-content .citation-reference>span.fn-bracket,.rst-content .footnote-reference>span.fn-bracket{display:none}.rst-content .hlist{width:100%}.rst-content dl dt span.classifier:before{content:" : "}.rst-content dl dt span.classifier-delimiter{display:none!important}html.writer-html4 .rst-content table.docutils.citation,html.writer-html4 .rst-content table.docutils.footnote{background:none;border:none}html.writer-html4 .rst-content table.docutils.citation td,html.writer-html4 .rst-content table.docutils.citation tr,html.writer-html4 .rst-content table.docutils.footnote td,html.writer-html4 .rst-content table.docutils.footnote tr{border:none;background-color:transparent!important;white-space:normal}html.writer-html4 .rst-content table.docutils.citation td.label,html.writer-html4 .rst-content table.docutils.footnote td.label{padding-left:0;padding-right:0;vertical-align:top}html.writer-html5 .rst-content dl.citation,html.writer-html5 .rst-content dl.field-list,html.writer-html5 .rst-content dl.footnote{display:grid;grid-template-columns:auto minmax(80%,95%)}html.writer-html5 .rst-content dl.citation>dt,html.writer-html5 .rst-content dl.field-list>dt,html.writer-html5 .rst-content dl.footnote>dt{display:inline-grid;grid-template-columns:max-content auto}html.writer-html5 .rst-content aside.citation,html.writer-html5 .rst-content aside.footnote,html.writer-html5 .rst-content div.citation{display:grid;grid-template-columns:auto auto minmax(.65rem,auto) minmax(40%,95%)}html.writer-html5 .rst-content aside.citation>span.label,html.writer-html5 .rst-content aside.footnote>span.label,html.writer-html5 .rst-content div.citation>span.label{grid-column-start:1;grid-column-end:2}html.writer-html5 .rst-content aside.citation>span.backrefs,html.writer-html5 .rst-content aside.footnote>span.backrefs,html.writer-html5 .rst-content div.citation>span.backrefs{grid-column-start:2;grid-column-end:3;grid-row-start:1;grid-row-end:3}html.writer-html5 .rst-content aside.citation>p,html.writer-html5 .rst-content aside.footnote>p,html.writer-html5 .rst-content div.citation>p{grid-column-start:4;grid-column-end:5}html.writer-html5 .rst-content dl.citation,html.writer-html5 .rst-content dl.field-list,html.writer-html5 .rst-content dl.footnote{margin-bottom:24px}html.writer-html5 .rst-content dl.citation>dt,html.writer-html5 .rst-content dl.field-list>dt,html.writer-html5 .rst-content dl.footnote>dt{padding-left:1rem}html.writer-html5 .rst-content dl.citation>dd,html.writer-html5 .rst-content dl.citation>dt,html.writer-html5 .rst-content dl.field-list>dd,html.writer-html5 .rst-content dl.field-list>dt,html.writer-html5 .rst-content dl.footnote>dd,html.writer-html5 .rst-content dl.footnote>dt{margin-bottom:0}html.writer-html5 .rst-content dl.citation,html.writer-html5 .rst-content dl.footnote{font-size:.9rem}html.writer-html5 .rst-content dl.citation>dt,html.writer-html5 .rst-content dl.footnote>dt{margin:0 .5rem .5rem 0;line-height:1.2rem;word-break:break-all;font-weight:400}html.writer-html5 .rst-content dl.citation>dt>span.brackets:before,html.writer-html5 .rst-content dl.footnote>dt>span.brackets:before{content:"["}html.writer-html5 .rst-content dl.citation>dt>span.brackets:after,html.writer-html5 .rst-content dl.footnote>dt>span.brackets:after{content:"]"}html.writer-html5 .rst-content dl.citation>dt>span.fn-backref,html.writer-html5 .rst-content dl.footnote>dt>span.fn-backref{text-align:left;font-style:italic;margin-left:.65rem;word-break:break-word;word-spacing:-.1rem;max-width:5rem}html.writer-html5 .rst-content dl.citation>dt>span.fn-backref>a,html.writer-html5 .rst-content dl.footnote>dt>span.fn-backref>a{word-break:keep-all}html.writer-html5 .rst-content dl.citation>dt>span.fn-backref>a:not(:first-child):before,html.writer-html5 .rst-content dl.footnote>dt>span.fn-backref>a:not(:first-child):before{content:" "}html.writer-html5 .rst-content dl.citation>dd,html.writer-html5 .rst-content dl.footnote>dd{margin:0 0 .5rem;line-height:1.2rem}html.writer-html5 .rst-content dl.citation>dd p,html.writer-html5 .rst-content dl.footnote>dd p{font-size:.9rem}html.writer-html5 .rst-content aside.citation,html.writer-html5 .rst-content aside.footnote,html.writer-html5 .rst-content div.citation{padding-left:1rem;padding-right:1rem;font-size:.9rem;line-height:1.2rem}html.writer-html5 .rst-content aside.citation p,html.writer-html5 .rst-content aside.footnote p,html.writer-html5 .rst-content div.citation p{font-size:.9rem;line-height:1.2rem;margin-bottom:12px}html.writer-html5 .rst-content aside.citation span.backrefs,html.writer-html5 .rst-content aside.footnote span.backrefs,html.writer-html5 .rst-content div.citation span.backrefs{text-align:left;font-style:italic;margin-left:.65rem;word-break:break-word;word-spacing:-.1rem;max-width:5rem}html.writer-html5 .rst-content aside.citation span.backrefs>a,html.writer-html5 .rst-content aside.footnote span.backrefs>a,html.writer-html5 .rst-content div.citation span.backrefs>a{word-break:keep-all}html.writer-html5 .rst-content aside.citation span.backrefs>a:not(:first-child):before,html.writer-html5 .rst-content aside.footnote span.backrefs>a:not(:first-child):before,html.writer-html5 .rst-content div.citation span.backrefs>a:not(:first-child):before{content:" "}html.writer-html5 .rst-content aside.citation span.label,html.writer-html5 .rst-content aside.footnote span.label,html.writer-html5 .rst-content div.citation span.label{line-height:1.2rem}html.writer-html5 .rst-content aside.citation-list,html.writer-html5 .rst-content aside.footnote-list,html.writer-html5 .rst-content div.citation-list{margin-bottom:24px}html.writer-html5 .rst-content dl.option-list kbd{font-size:.9rem}.rst-content table.docutils.footnote,html.writer-html4 .rst-content table.docutils.citation,html.writer-html5 .rst-content aside.footnote,html.writer-html5 .rst-content aside.footnote-list aside.footnote,html.writer-html5 .rst-content div.citation-list>div.citation,html.writer-html5 .rst-content dl.citation,html.writer-html5 .rst-content dl.footnote{color:grey}.rst-content table.docutils.footnote code,.rst-content table.docutils.footnote tt,html.writer-html4 .rst-content table.docutils.citation code,html.writer-html4 .rst-content table.docutils.citation tt,html.writer-html5 .rst-content aside.footnote-list aside.footnote code,html.writer-html5 .rst-content aside.footnote-list aside.footnote tt,html.writer-html5 .rst-content aside.footnote code,html.writer-html5 .rst-content aside.footnote tt,html.writer-html5 .rst-content div.citation-list>div.citation code,html.writer-html5 .rst-content div.citation-list>div.citation tt,html.writer-html5 .rst-content dl.citation code,html.writer-html5 .rst-content dl.citation tt,html.writer-html5 .rst-content dl.footnote code,html.writer-html5 .rst-content dl.footnote tt{color:#555}.rst-content .wy-table-responsive.citation,.rst-content .wy-table-responsive.footnote{margin-bottom:0}.rst-content .wy-table-responsive.citation+:not(.citation),.rst-content .wy-table-responsive.footnote+:not(.footnote){margin-top:24px}.rst-content .wy-table-responsive.citation:last-child,.rst-content .wy-table-responsive.footnote:last-child{margin-bottom:24px}.rst-content table.docutils th{border-color:#e1e4e5}html.writer-html5 .rst-content table.docutils th{border:1px solid #e1e4e5}html.writer-html5 .rst-content table.docutils td>p,html.writer-html5 .rst-content table.docutils th>p{line-height:1rem;margin-bottom:0;font-size:.9rem}.rst-content table.docutils td .last,.rst-content table.docutils td .last>:last-child{margin-bottom:0}.rst-content table.field-list,.rst-content table.field-list td{border:none}.rst-content table.field-list td p{line-height:inherit}.rst-content table.field-list td>strong{display:inline-block}.rst-content table.field-list .field-name{padding-right:10px;text-align:left;white-space:nowrap}.rst-content table.field-list .field-body{text-align:left}.rst-content code,.rst-content tt{color:#000;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;padding:2px 5px}.rst-content code big,.rst-content code em,.rst-content tt big,.rst-content tt em{font-size:100%!important;line-height:normal}.rst-content code.literal,.rst-content tt.literal{color:#e74c3c;white-space:normal}.rst-content code.xref,.rst-content tt.xref,a .rst-content code,a .rst-content tt{font-weight:700;color:#404040;overflow-wrap:normal}.rst-content kbd,.rst-content pre,.rst-content samp{font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace}.rst-content a code,.rst-content a tt{color:#2980b9}.rst-content dl{margin-bottom:24px}.rst-content dl dt{font-weight:700;margin-bottom:12px}.rst-content dl ol,.rst-content dl p,.rst-content dl table,.rst-content dl ul{margin-bottom:12px}.rst-content dl dd{margin:0 0 12px 24px;line-height:24px}.rst-content dl dd>ol:last-child,.rst-content dl dd>p:last-child,.rst-content dl dd>table:last-child,.rst-content dl dd>ul:last-child{margin-bottom:0}html.writer-html4 .rst-content dl:not(.docutils),html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple){margin-bottom:24px}html.writer-html4 .rst-content dl:not(.docutils)>dt,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt{display:table;margin:6px 0;font-size:90%;line-height:normal;background:#e7f2fa;color:#2980b9;border-top:3px solid #6ab0de;padding:6px;position:relative}html.writer-html4 .rst-content dl:not(.docutils)>dt:before,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt:before{color:#6ab0de}html.writer-html4 .rst-content dl:not(.docutils)>dt .headerlink,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt .headerlink{color:#404040;font-size:100%!important}html.writer-html4 .rst-content dl:not(.docutils) dl:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) dl:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt{margin-bottom:6px;border:none;border-left:3px solid #ccc;background:#f0f0f0;color:#555}html.writer-html4 .rst-content dl:not(.docutils) dl:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt .headerlink,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) dl:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt .headerlink{color:#404040;font-size:100%!important}html.writer-html4 .rst-content dl:not(.docutils)>dt:first-child,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt:first-child{margin-top:0}html.writer-html4 .rst-content dl:not(.docutils) code.descclassname,html.writer-html4 .rst-content dl:not(.docutils) code.descname,html.writer-html4 .rst-content dl:not(.docutils) tt.descclassname,html.writer-html4 .rst-content dl:not(.docutils) tt.descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) code.descclassname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) code.descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) tt.descclassname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) tt.descname{background-color:transparent;border:none;padding:0;font-size:100%!important}html.writer-html4 .rst-content dl:not(.docutils) code.descname,html.writer-html4 .rst-content dl:not(.docutils) tt.descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) code.descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) tt.descname{font-weight:700}html.writer-html4 .rst-content dl:not(.docutils) .optional,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .optional{display:inline-block;padding:0 4px;color:#000;font-weight:700}html.writer-html4 .rst-content dl:not(.docutils) .property,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .property{display:inline-block;padding-right:8px;max-width:100%}html.writer-html4 .rst-content dl:not(.docutils) .k,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .k{font-style:italic}html.writer-html4 .rst-content dl:not(.docutils) .descclassname,html.writer-html4 .rst-content dl:not(.docutils) .descname,html.writer-html4 .rst-content dl:not(.docutils) .sig-name,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .descclassname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .sig-name{font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;color:#000}.rst-content .viewcode-back,.rst-content .viewcode-link{display:inline-block;color:#27ae60;font-size:80%;padding-left:24px}.rst-content .viewcode-back{display:block;float:right}.rst-content p.rubric{margin-bottom:12px;font-weight:700}.rst-content code.download,.rst-content tt.download{background:inherit;padding:inherit;font-weight:400;font-family:inherit;font-size:inherit;color:inherit;border:inherit;white-space:inherit}.rst-content code.download span:first-child,.rst-content tt.download span:first-child{-webkit-font-smoothing:subpixel-antialiased}.rst-content code.download span:first-child:before,.rst-content tt.download span:first-child:before{margin-right:4px}.rst-content .guilabel,.rst-content .menuselection{font-size:80%;font-weight:700;border-radius:4px;padding:2.4px 6px;margin:auto 2px}.rst-content .guilabel,.rst-content .menuselection{border:1px solid #7fbbe3;background:#e7f2fa}.rst-content :not(dl.option-list)>:not(dt):not(kbd):not(.kbd)>.kbd,.rst-content :not(dl.option-list)>:not(dt):not(kbd):not(.kbd)>kbd{color:inherit;font-size:80%;background-color:#fff;border:1px solid #a6a6a6;border-radius:4px;box-shadow:0 2px grey;padding:2.4px 6px;margin:auto 0}.rst-content .versionmodified{font-style:italic}@media screen and (max-width:480px){.rst-content .sidebar{width:100%}}span[id*=MathJax-Span]{color:#404040}.math{text-align:center}@font-face{font-family:Lato;src:url(fonts/lato-normal.woff2?bd03a2cc277bbbc338d464e679fe9942) format("woff2"),url(fonts/lato-normal.woff?27bd77b9162d388cb8d4c4217c7c5e2a) format("woff");font-weight:400;font-style:normal;font-display:block}@font-face{font-family:Lato;src:url(fonts/lato-bold.woff2?cccb897485813c7c256901dbca54ecf2) format("woff2"),url(fonts/lato-bold.woff?d878b6c29b10beca227e9eef4246111b) format("woff");font-weight:700;font-style:normal;font-display:block}@font-face{font-family:Lato;src:url(fonts/lato-bold-italic.woff2?0b6bb6725576b072c5d0b02ecdd1900d) format("woff2"),url(fonts/lato-bold-italic.woff?9c7e4e9eb485b4a121c760e61bc3707c) format("woff");font-weight:700;font-style:italic;font-display:block}@font-face{font-family:Lato;src:url(fonts/lato-normal-italic.woff2?4eb103b4d12be57cb1d040ed5e162e9d) format("woff2"),url(fonts/lato-normal-italic.woff?f28f2d6482446544ef1ea1ccc6dd5892) format("woff");font-weight:400;font-style:italic;font-display:block}@font-face{font-family:Roboto Slab;font-style:normal;font-weight:400;src:url(fonts/Roboto-Slab-Regular.woff2?7abf5b8d04d26a2cafea937019bca958) format("woff2"),url(fonts/Roboto-Slab-Regular.woff?c1be9284088d487c5e3ff0a10a92e58c) format("woff");font-display:block}@font-face{font-family:Roboto Slab;font-style:normal;font-weight:700;src:url(fonts/Roboto-Slab-Bold.woff2?9984f4a9bda09be08e83f2506954adbe) format("woff2"),url(fonts/Roboto-Slab-Bold.woff?bed5564a116b05148e3b3bea6fb1162a) format("woff");font-display:block}
\ No newline at end of file
diff --git a/docs/html/_static/doctools.js b/docs/html/_static/doctools.js
index e509e48..d06a71d 100644
--- a/docs/html/_static/doctools.js
+++ b/docs/html/_static/doctools.js
@@ -2,325 +2,155 @@
  * doctools.js
  * ~~~~~~~~~~~
  *
- * Sphinx JavaScript utilities for all documentation.
+ * Base JavaScript utilities for all Sphinx HTML documentation.
  *
- * :copyright: Copyright 2007-2022 by the Sphinx team, see AUTHORS.
+ * :copyright: Copyright 2007-2023 by the Sphinx team, see AUTHORS.
  * :license: BSD, see LICENSE for details.
  *
  */
-
-/**
- * select a different prefix for underscore
- */
-$u = _.noConflict();
-
-/**
- * make the code below compatible with browsers without
- * an installed firebug like debugger
-if (!window.console || !console.firebug) {
-  var names = ["log", "debug", "info", "warn", "error", "assert", "dir",
-    "dirxml", "group", "groupEnd", "time", "timeEnd", "count", "trace",
-    "profile", "profileEnd"];
-  window.console = {};
-  for (var i = 0; i < names.length; ++i)
-    window.console[names[i]] = function() {};
-}
- */
-
-/**
- * small helper function to urldecode strings
- *
- * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/decodeURIComponent#Decoding_query_parameters_from_a_URL
- */
-jQuery.urldecode = function(x) {
-  if (!x) {
-    return x
-  }
-  return decodeURIComponent(x.replace(/\+/g, ' '));
-};
-
-/**
- * small helper function to urlencode strings
- */
-jQuery.urlencode = encodeURIComponent;
-
-/**
- * This function returns the parsed url parameters of the
- * current request. Multiple values per key are supported,
- * it will always return arrays of strings for the value parts.
- */
-jQuery.getQueryParameters = function(s) {
-  if (typeof s === 'undefined')
-    s = document.location.search;
-  var parts = s.substr(s.indexOf('?') + 1).split('&');
-  var result = {};
-  for (var i = 0; i < parts.length; i++) {
-    var tmp = parts[i].split('=', 2);
-    var key = jQuery.urldecode(tmp[0]);
-    var value = jQuery.urldecode(tmp[1]);
-    if (key in result)
-      result[key].push(value);
-    else
-      result[key] = [value];
+"use strict";
+
+const BLACKLISTED_KEY_CONTROL_ELEMENTS = new Set([
+  "TEXTAREA",
+  "INPUT",
+  "SELECT",
+  "BUTTON",
+]);
+
+const _ready = (callback) => {
+  if (document.readyState !== "loading") {
+    callback();
+  } else {
+    document.addEventListener("DOMContentLoaded", callback);
   }
-  return result;
 };
 
-/**
- * highlight a given string on a jquery object by wrapping it in
- * span elements with the given class name.
- */
-jQuery.fn.highlightText = function(text, className) {
-  function highlight(node, addItems) {
-    if (node.nodeType === 3) {
-      var val = node.nodeValue;
-      var pos = val.toLowerCase().indexOf(text);
-      if (pos >= 0 &&
-          !jQuery(node.parentNode).hasClass(className) &&
-          !jQuery(node.parentNode).hasClass("nohighlight")) {
-        var span;
-        var isInSVG = jQuery(node).closest("body, svg, foreignObject").is("svg");
-        if (isInSVG) {
-          span = document.createElementNS("http://www.w3.org/2000/svg", "tspan");
-        } else {
-          span = document.createElement("span");
-          span.className = className;
-        }
-        span.appendChild(document.createTextNode(val.substr(pos, text.length)));
-        node.parentNode.insertBefore(span, node.parentNode.insertBefore(
-          document.createTextNode(val.substr(pos + text.length)),
-          node.nextSibling));
-        node.nodeValue = val.substr(0, pos);
-        if (isInSVG) {
-          var rect = document.createElementNS("http://www.w3.org/2000/svg", "rect");
-          var bbox = node.parentElement.getBBox();
-          rect.x.baseVal.value = bbox.x;
-          rect.y.baseVal.value = bbox.y;
-          rect.width.baseVal.value = bbox.width;
-          rect.height.baseVal.value = bbox.height;
-          rect.setAttribute('class', className);
-          addItems.push({
-              "parent": node.parentNode,
-              "target": rect});
-        }
-      }
-    }
-    else if (!jQuery(node).is("button, select, textarea")) {
-      jQuery.each(node.childNodes, function() {
-        highlight(this, addItems);
-      });
-    }
-  }
-  var addItems = [];
-  var result = this.each(function() {
-    highlight(this, addItems);
-  });
-  for (var i = 0; i < addItems.length; ++i) {
-    jQuery(addItems[i].parent).before(addItems[i].target);
-  }
-  return result;
-};
-
-/*
- * backward compatibility for jQuery.browser
- * This will be supported until firefox bug is fixed.
- */
-if (!jQuery.browser) {
-  jQuery.uaMatch = function(ua) {
-    ua = ua.toLowerCase();
-
-    var match = /(chrome)[ \/]([\w.]+)/.exec(ua) ||
-      /(webkit)[ \/]([\w.]+)/.exec(ua) ||
-      /(opera)(?:.*version|)[ \/]([\w.]+)/.exec(ua) ||
-      /(msie) ([\w.]+)/.exec(ua) ||
-      ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(ua) ||
-      [];
-
-    return {
-      browser: match[ 1 ] || "",
-      version: match[ 2 ] || "0"
-    };
-  };
-  jQuery.browser = {};
-  jQuery.browser[jQuery.uaMatch(navigator.userAgent).browser] = true;
-}
-
 /**
  * Small JavaScript module for the documentation.
  */
-var Documentation = {
-
-  init : function() {
-    this.fixFirefoxAnchorBug();
-    this.highlightSearchWords();
-    this.initIndexTable();
-    if (DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS) {
-      this.initOnKeyListeners();
-    }
+const Documentation = {
+  init: () => {
+    Documentation.initDomainIndexTable();
+    Documentation.initOnKeyListeners();
   },
 
   /**
    * i18n support
    */
-  TRANSLATIONS : {},
-  PLURAL_EXPR : function(n) { return n === 1 ? 0 : 1; },
-  LOCALE : 'unknown',
+  TRANSLATIONS: {},
+  PLURAL_EXPR: (n) => (n === 1 ? 0 : 1),
+  LOCALE: "unknown",
 
   // gettext and ngettext don't access this so that the functions
   // can safely bound to a different name (_ = Documentation.gettext)
-  gettext : function(string) {
-    var translated = Documentation.TRANSLATIONS[string];
-    if (typeof translated === 'undefined')
-      return string;
-    return (typeof translated === 'string') ? translated : translated[0];
+  gettext: (string) => {
+    const translated = Documentation.TRANSLATIONS[string];
+    switch (typeof translated) {
+      case "undefined":
+        return string; // no translation
+      case "string":
+        return translated; // translation exists
+      default:
+        return translated[0]; // (singular, plural) translation tuple exists
+    }
   },
 
-  ngettext : function(singular, plural, n) {
-    var translated = Documentation.TRANSLATIONS[singular];
-    if (typeof translated === 'undefined')
-      return (n == 1) ? singular : plural;
-    return translated[Documentation.PLURALEXPR(n)];
+  ngettext: (singular, plural, n) => {
+    const translated = Documentation.TRANSLATIONS[singular];
+    if (typeof translated !== "undefined")
+      return translated[Documentation.PLURAL_EXPR(n)];
+    return n === 1 ? singular : plural;
   },
 
-  addTranslations : function(catalog) {
-    for (var key in catalog.messages)
-      this.TRANSLATIONS[key] = catalog.messages[key];
-    this.PLURAL_EXPR = new Function('n', 'return +(' + catalog.plural_expr + ')');
-    this.LOCALE = catalog.locale;
+  addTranslations: (catalog) => {
+    Object.assign(Documentation.TRANSLATIONS, catalog.messages);
+    Documentation.PLURAL_EXPR = new Function(
+      "n",
+      `return (${catalog.plural_expr})`
+    );
+    Documentation.LOCALE = catalog.locale;
   },
 
   /**
-   * add context elements like header anchor links
+   * helper function to focus on search bar
    */
-  addContextElements : function() {
-    $('div[id] > :header:first').each(function() {
-      $('<a class="headerlink">\u00B6</a>').
-      attr('href', '#' + this.id).
-      attr('title', _('Permalink to this headline')).
-      appendTo(this);
-    });
-    $('dt[id]').each(function() {
-      $('<a class="headerlink">\u00B6</a>').
-      attr('href', '#' + this.id).
-      attr('title', _('Permalink to this definition')).
-      appendTo(this);
-    });
+  focusSearchBar: () => {
+    document.querySelectorAll("input[name=q]")[0]?.focus();
   },
 
   /**
-   * workaround a firefox stupidity
-   * see: https://bugzilla.mozilla.org/show_bug.cgi?id=645075
+   * Initialise the domain index toggle buttons
    */
-  fixFirefoxAnchorBug : function() {
-    if (document.location.hash && $.browser.mozilla)
-      window.setTimeout(function() {
-        document.location.href += '';
-      }, 10);
-  },
-
-  /**
-   * highlight the search words provided in the url in the text
-   */
-  highlightSearchWords : function() {
-    var params = $.getQueryParameters();
-    var terms = (params.highlight) ? params.highlight[0].split(/\s+/) : [];
-    if (terms.length) {
-      var body = $('div.body');
-      if (!body.length) {
-        body = $('body');
+  initDomainIndexTable: () => {
+    const toggler = (el) => {
+      const idNumber = el.id.substr(7);
+      const toggledRows = document.querySelectorAll(`tr.cg-${idNumber}`);
+      if (el.src.substr(-9) === "minus.png") {
+        el.src = `${el.src.substr(0, el.src.length - 9)}plus.png`;
+        toggledRows.forEach((el) => (el.style.display = "none"));
+      } else {
+        el.src = `${el.src.substr(0, el.src.length - 8)}minus.png`;
+        toggledRows.forEach((el) => (el.style.display = ""));
       }
-      window.setTimeout(function() {
-        $.each(terms, function() {
-          body.highlightText(this.toLowerCase(), 'highlighted');
-        });
-      }, 10);
-      $('<p class="highlight-link"><a href="javascript:Documentation.' +
-        'hideSearchWords()">' + _('Hide Search Matches') + '</a></p>')
-          .appendTo($('#searchbox'));
-    }
-  },
-
-  /**
-   * init the domain index toggle buttons
-   */
-  initIndexTable : function() {
-    var togglers = $('img.toggler').click(function() {
-      var src = $(this).attr('src');
-      var idnum = $(this).attr('id').substr(7);
-      $('tr.cg-' + idnum).toggle();
-      if (src.substr(-9) === 'minus.png')
-        $(this).attr('src', src.substr(0, src.length-9) + 'plus.png');
-      else
-        $(this).attr('src', src.substr(0, src.length-8) + 'minus.png');
-    }).css('display', '');
-    if (DOCUMENTATION_OPTIONS.COLLAPSE_INDEX) {
-        togglers.click();
-    }
-  },
+    };
 
-  /**
-   * helper function to hide the search marks again
-   */
-  hideSearchWords : function() {
-    $('#searchbox .highlight-link').fadeOut(300);
-    $('span.highlighted').removeClass('highlighted');
-    var url = new URL(window.location);
-    url.searchParams.delete('highlight');
-    window.history.replaceState({}, '', url);
+    const togglerElements = document.querySelectorAll("img.toggler");
+    togglerElements.forEach((el) =>
+      el.addEventListener("click", (event) => toggler(event.currentTarget))
+    );
+    togglerElements.forEach((el) => (el.style.display = ""));
+    if (DOCUMENTATION_OPTIONS.COLLAPSE_INDEX) togglerElements.forEach(toggler);
   },
 
-  /**
-   * make the url absolute
-   */
-  makeURL : function(relativeURL) {
-    return DOCUMENTATION_OPTIONS.URL_ROOT + '/' + relativeURL;
-  },
-
-  /**
-   * get the current relative url
-   */
-  getCurrentURL : function() {
-    var path = document.location.pathname;
-    var parts = path.split(/\//);
-    $.each(DOCUMENTATION_OPTIONS.URL_ROOT.split(/\//), function() {
-      if (this === '..')
-        parts.pop();
-    });
-    var url = parts.join('/');
-    return path.substring(url.lastIndexOf('/') + 1, path.length - 1);
-  },
-
-  initOnKeyListeners: function() {
-    $(document).keydown(function(event) {
-      var activeElementType = document.activeElement.tagName;
-      // don't navigate when in search box, textarea, dropdown or button
-      if (activeElementType !== 'TEXTAREA' && activeElementType !== 'INPUT' && activeElementType !== 'SELECT'
-          && activeElementType !== 'BUTTON' && !event.altKey && !event.ctrlKey && !event.metaKey
-          && !event.shiftKey) {
-        switch (event.keyCode) {
-          case 37: // left
-            var prevHref = $('link[rel="prev"]').prop('href');
-            if (prevHref) {
-              window.location.href = prevHref;
-              return false;
+  initOnKeyListeners: () => {
+    // only install a listener if it is really needed
+    if (
+      !DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS &&
+      !DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS
+    )
+      return;
+
+    document.addEventListener("keydown", (event) => {
+      // bail for input elements
+      if (BLACKLISTED_KEY_CONTROL_ELEMENTS.has(document.activeElement.tagName)) return;
+      // bail with special keys
+      if (event.altKey || event.ctrlKey || event.metaKey) return;
+
+      if (!event.shiftKey) {
+        switch (event.key) {
+          case "ArrowLeft":
+            if (!DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS) break;
+
+            const prevLink = document.querySelector('link[rel="prev"]');
+            if (prevLink && prevLink.href) {
+              window.location.href = prevLink.href;
+              event.preventDefault();
             }
             break;
-          case 39: // right
-            var nextHref = $('link[rel="next"]').prop('href');
-            if (nextHref) {
-              window.location.href = nextHref;
-              return false;
+          case "ArrowRight":
+            if (!DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS) break;
+
+            const nextLink = document.querySelector('link[rel="next"]');
+            if (nextLink && nextLink.href) {
+              window.location.href = nextLink.href;
+              event.preventDefault();
             }
             break;
         }
       }
+
+      // some keyboard layouts may need Shift to get /
+      switch (event.key) {
+        case "/":
+          if (!DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS) break;
+          Documentation.focusSearchBar();
+          event.preventDefault();
+      }
     });
-  }
+  },
 };
 
 // quick alias for translations
-_ = Documentation.gettext;
+const _ = Documentation.gettext;
 
-$(document).ready(function() {
-  Documentation.init();
-});
+_ready(Documentation.init);
diff --git a/docs/html/_static/documentation_options.js b/docs/html/_static/documentation_options.js
index 804564e..5bef6f4 100644
--- a/docs/html/_static/documentation_options.js
+++ b/docs/html/_static/documentation_options.js
@@ -1,12 +1,14 @@
 var DOCUMENTATION_OPTIONS = {
     URL_ROOT: document.getElementById("documentation_options").getAttribute('data-url_root'),
     VERSION: '1.1',
-    LANGUAGE: 'None',
+    LANGUAGE: 'en',
     COLLAPSE_INDEX: false,
     BUILDER: 'html',
     FILE_SUFFIX: '.html',
     LINK_SUFFIX: '.html',
     HAS_SOURCE: true,
     SOURCELINK_SUFFIX: '.txt',
-    NAVIGATION_WITH_KEYS: false
+    NAVIGATION_WITH_KEYS: false,
+    SHOW_SEARCH_SUMMARY: true,
+    ENABLE_SEARCH_SHORTCUTS: true,
 };
\ No newline at end of file
diff --git a/docs/html/_static/jquery.js b/docs/html/_static/jquery.js
index b061403..c4c6022 100644
--- a/docs/html/_static/jquery.js
+++ b/docs/html/_static/jquery.js
@@ -1,2 +1,2 @@
-/*! jQuery v3.5.1 | (c) JS Foundation and other contributors | jquery.org/license */
-!function(e,t){"use strict";"object"==typeof module&&"object"==typeof module.exports?module.exports=e.document?t(e,!0):function(e){if(!e.document)throw new Error("jQuery requires a window with a document");return t(e)}:t(e)}("undefined"!=typeof window?window:this,function(C,e){"use strict";var t=[],r=Object.getPrototypeOf,s=t.slice,g=t.flat?function(e){return t.flat.call(e)}:function(e){return t.concat.apply([],e)},u=t.push,i=t.indexOf,n={},o=n.toString,v=n.hasOwnProperty,a=v.toString,l=a.call(Object),y={},m=function(e){return"function"==typeof e&&"number"!=typeof e.nodeType},x=function(e){return null!=e&&e===e.window},E=C.document,c={type:!0,src:!0,nonce:!0,noModule:!0};function b(e,t,n){var r,i,o=(n=n||E).createElement("script");if(o.text=e,t)for(r in c)(i=t[r]||t.getAttribute&&t.getAttribute(r))&&o.setAttribute(r,i);n.head.appendChild(o).parentNode.removeChild(o)}function w(e){return null==e?e+"":"object"==typeof e||"function"==typeof e?n[o.call(e)]||"object":typeof e}var f="3.5.1",S=function(e,t){return new S.fn.init(e,t)};function p(e){var t=!!e&&"length"in e&&e.length,n=w(e);return!m(e)&&!x(e)&&("array"===n||0===t||"number"==typeof t&&0<t&&t-1 in e)}S.fn=S.prototype={jquery:f,constructor:S,length:0,toArray:function(){return s.call(this)},get:function(e){return null==e?s.call(this):e<0?this[e+this.length]:this[e]},pushStack:function(e){var t=S.merge(this.constructor(),e);return t.prevObject=this,t},each:function(e){return S.each(this,e)},map:function(n){return this.pushStack(S.map(this,function(e,t){return n.call(e,t,e)}))},slice:function(){return this.pushStack(s.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},even:function(){return this.pushStack(S.grep(this,function(e,t){return(t+1)%2}))},odd:function(){return this.pushStack(S.grep(this,function(e,t){return t%2}))},eq:function(e){var t=this.length,n=+e+(e<0?t:0);return this.pushStack(0<=n&&n<t?[this[n]]:[])},end:function(){return this.prevObject||this.constructor()},push:u,sort:t.sort,splice:t.splice},S.extend=S.fn.extend=function(){var e,t,n,r,i,o,a=arguments[0]||{},s=1,u=arguments.length,l=!1;for("boolean"==typeof a&&(l=a,a=arguments[s]||{},s++),"object"==typeof a||m(a)||(a={}),s===u&&(a=this,s--);s<u;s++)if(null!=(e=arguments[s]))for(t in e)r=e[t],"__proto__"!==t&&a!==r&&(l&&r&&(S.isPlainObject(r)||(i=Array.isArray(r)))?(n=a[t],o=i&&!Array.isArray(n)?[]:i||S.isPlainObject(n)?n:{},i=!1,a[t]=S.extend(l,o,r)):void 0!==r&&(a[t]=r));return a},S.extend({expando:"jQuery"+(f+Math.random()).replace(/\D/g,""),isReady:!0,error:function(e){throw new Error(e)},noop:function(){},isPlainObject:function(e){var t,n;return!(!e||"[object Object]"!==o.call(e))&&(!(t=r(e))||"function"==typeof(n=v.call(t,"constructor")&&t.constructor)&&a.call(n)===l)},isEmptyObject:function(e){var t;for(t in e)return!1;return!0},globalEval:function(e,t,n){b(e,{nonce:t&&t.nonce},n)},each:function(e,t){var n,r=0;if(p(e)){for(n=e.length;r<n;r++)if(!1===t.call(e[r],r,e[r]))break}else for(r in e)if(!1===t.call(e[r],r,e[r]))break;return e},makeArray:function(e,t){var n=t||[];return null!=e&&(p(Object(e))?S.merge(n,"string"==typeof e?[e]:e):u.call(n,e)),n},inArray:function(e,t,n){return null==t?-1:i.call(t,e,n)},merge:function(e,t){for(var n=+t.length,r=0,i=e.length;r<n;r++)e[i++]=t[r];return e.length=i,e},grep:function(e,t,n){for(var r=[],i=0,o=e.length,a=!n;i<o;i++)!t(e[i],i)!==a&&r.push(e[i]);return r},map:function(e,t,n){var r,i,o=0,a=[];if(p(e))for(r=e.length;o<r;o++)null!=(i=t(e[o],o,n))&&a.push(i);else for(o in e)null!=(i=t(e[o],o,n))&&a.push(i);return g(a)},guid:1,support:y}),"function"==typeof Symbol&&(S.fn[Symbol.iterator]=t[Symbol.iterator]),S.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "),function(e,t){n["[object "+t+"]"]=t.toLowerCase()});var d=function(n){var e,d,b,o,i,h,f,g,w,u,l,T,C,a,E,v,s,c,y,S="sizzle"+1*new Date,p=n.document,k=0,r=0,m=ue(),x=ue(),A=ue(),N=ue(),D=function(e,t){return e===t&&(l=!0),0},j={}.hasOwnProperty,t=[],q=t.pop,L=t.push,H=t.push,O=t.slice,P=function(e,t){for(var n=0,r=e.length;n<r;n++)if(e[n]===t)return n;return-1},R="checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",M="[\\x20\\t\\r\\n\\f]",I="(?:\\\\[\\da-fA-F]{1,6}"+M+"?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+",W="\\["+M+"*("+I+")(?:"+M+"*([*^$|!~]?=)"+M+"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|("+I+"))|)"+M+"*\\]",F=":("+I+")(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[\\]]|"+W+")*)|.*)\\)|)",B=new RegExp(M+"+","g"),$=new RegExp("^"+M+"+|((?:^|[^\\\\])(?:\\\\.)*)"+M+"+$","g"),_=new RegExp("^"+M+"*,"+M+"*"),z=new RegExp("^"+M+"*([>+~]|"+M+")"+M+"*"),U=new RegExp(M+"|>"),X=new RegExp(F),V=new RegExp("^"+I+"$"),G={ID:new RegExp("^#("+I+")"),CLASS:new RegExp("^\\.("+I+")"),TAG:new RegExp("^("+I+"|[*])"),ATTR:new RegExp("^"+W),PSEUDO:new RegExp("^"+F),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+M+"*(even|odd|(([+-]|)(\\d*)n|)"+M+"*(?:([+-]|)"+M+"*(\\d+)|))"+M+"*\\)|)","i"),bool:new RegExp("^(?:"+R+")$","i"),needsContext:new RegExp("^"+M+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+M+"*((?:-\\d)?\\d*)"+M+"*\\)|)(?=[^-]|$)","i")},Y=/HTML$/i,Q=/^(?:input|select|textarea|button)$/i,J=/^h\d$/i,K=/^[^{]+\{\s*\[native \w/,Z=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,ee=/[+~]/,te=new RegExp("\\\\[\\da-fA-F]{1,6}"+M+"?|\\\\([^\\r\\n\\f])","g"),ne=function(e,t){var n="0x"+e.slice(1)-65536;return t||(n<0?String.fromCharCode(n+65536):String.fromCharCode(n>>10|55296,1023&n|56320))},re=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,ie=function(e,t){return t?"\0"===e?"\ufffd":e.slice(0,-1)+"\\"+e.charCodeAt(e.length-1).toString(16)+" ":"\\"+e},oe=function(){T()},ae=be(function(e){return!0===e.disabled&&"fieldset"===e.nodeName.toLowerCase()},{dir:"parentNode",next:"legend"});try{H.apply(t=O.call(p.childNodes),p.childNodes),t[p.childNodes.length].nodeType}catch(e){H={apply:t.length?function(e,t){L.apply(e,O.call(t))}:function(e,t){var n=e.length,r=0;while(e[n++]=t[r++]);e.length=n-1}}}function se(t,e,n,r){var i,o,a,s,u,l,c,f=e&&e.ownerDocument,p=e?e.nodeType:9;if(n=n||[],"string"!=typeof t||!t||1!==p&&9!==p&&11!==p)return n;if(!r&&(T(e),e=e||C,E)){if(11!==p&&(u=Z.exec(t)))if(i=u[1]){if(9===p){if(!(a=e.getElementById(i)))return n;if(a.id===i)return n.push(a),n}else if(f&&(a=f.getElementById(i))&&y(e,a)&&a.id===i)return n.push(a),n}else{if(u[2])return H.apply(n,e.getElementsByTagName(t)),n;if((i=u[3])&&d.getElementsByClassName&&e.getElementsByClassName)return H.apply(n,e.getElementsByClassName(i)),n}if(d.qsa&&!N[t+" "]&&(!v||!v.test(t))&&(1!==p||"object"!==e.nodeName.toLowerCase())){if(c=t,f=e,1===p&&(U.test(t)||z.test(t))){(f=ee.test(t)&&ye(e.parentNode)||e)===e&&d.scope||((s=e.getAttribute("id"))?s=s.replace(re,ie):e.setAttribute("id",s=S)),o=(l=h(t)).length;while(o--)l[o]=(s?"#"+s:":scope")+" "+xe(l[o]);c=l.join(",")}try{return H.apply(n,f.querySelectorAll(c)),n}catch(e){N(t,!0)}finally{s===S&&e.removeAttribute("id")}}}return g(t.replace($,"$1"),e,n,r)}function ue(){var r=[];return function e(t,n){return r.push(t+" ")>b.cacheLength&&delete e[r.shift()],e[t+" "]=n}}function le(e){return e[S]=!0,e}function ce(e){var t=C.createElement("fieldset");try{return!!e(t)}catch(e){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function fe(e,t){var n=e.split("|"),r=n.length;while(r--)b.attrHandle[n[r]]=t}function pe(e,t){var n=t&&e,r=n&&1===e.nodeType&&1===t.nodeType&&e.sourceIndex-t.sourceIndex;if(r)return r;if(n)while(n=n.nextSibling)if(n===t)return-1;return e?1:-1}function de(t){return function(e){return"input"===e.nodeName.toLowerCase()&&e.type===t}}function he(n){return function(e){var t=e.nodeName.toLowerCase();return("input"===t||"button"===t)&&e.type===n}}function ge(t){return function(e){return"form"in e?e.parentNode&&!1===e.disabled?"label"in e?"label"in e.parentNode?e.parentNode.disabled===t:e.disabled===t:e.isDisabled===t||e.isDisabled!==!t&&ae(e)===t:e.disabled===t:"label"in e&&e.disabled===t}}function ve(a){return le(function(o){return o=+o,le(function(e,t){var n,r=a([],e.length,o),i=r.length;while(i--)e[n=r[i]]&&(e[n]=!(t[n]=e[n]))})})}function ye(e){return e&&"undefined"!=typeof e.getElementsByTagName&&e}for(e in d=se.support={},i=se.isXML=function(e){var t=e.namespaceURI,n=(e.ownerDocument||e).documentElement;return!Y.test(t||n&&n.nodeName||"HTML")},T=se.setDocument=function(e){var t,n,r=e?e.ownerDocument||e:p;return r!=C&&9===r.nodeType&&r.documentElement&&(a=(C=r).documentElement,E=!i(C),p!=C&&(n=C.defaultView)&&n.top!==n&&(n.addEventListener?n.addEventListener("unload",oe,!1):n.attachEvent&&n.attachEvent("onunload",oe)),d.scope=ce(function(e){return a.appendChild(e).appendChild(C.createElement("div")),"undefined"!=typeof e.querySelectorAll&&!e.querySelectorAll(":scope fieldset div").length}),d.attributes=ce(function(e){return e.className="i",!e.getAttribute("className")}),d.getElementsByTagName=ce(function(e){return e.appendChild(C.createComment("")),!e.getElementsByTagName("*").length}),d.getElementsByClassName=K.test(C.getElementsByClassName),d.getById=ce(function(e){return a.appendChild(e).id=S,!C.getElementsByName||!C.getElementsByName(S).length}),d.getById?(b.filter.ID=function(e){var t=e.replace(te,ne);return function(e){return e.getAttribute("id")===t}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n=t.getElementById(e);return n?[n]:[]}}):(b.filter.ID=function(e){var n=e.replace(te,ne);return function(e){var t="undefined"!=typeof e.getAttributeNode&&e.getAttributeNode("id");return t&&t.value===n}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n,r,i,o=t.getElementById(e);if(o){if((n=o.getAttributeNode("id"))&&n.value===e)return[o];i=t.getElementsByName(e),r=0;while(o=i[r++])if((n=o.getAttributeNode("id"))&&n.value===e)return[o]}return[]}}),b.find.TAG=d.getElementsByTagName?function(e,t){return"undefined"!=typeof t.getElementsByTagName?t.getElementsByTagName(e):d.qsa?t.querySelectorAll(e):void 0}:function(e,t){var n,r=[],i=0,o=t.getElementsByTagName(e);if("*"===e){while(n=o[i++])1===n.nodeType&&r.push(n);return r}return o},b.find.CLASS=d.getElementsByClassName&&function(e,t){if("undefined"!=typeof t.getElementsByClassName&&E)return t.getElementsByClassName(e)},s=[],v=[],(d.qsa=K.test(C.querySelectorAll))&&(ce(function(e){var t;a.appendChild(e).innerHTML="<a id='"+S+"'></a><select id='"+S+"-\r\\' msallowcapture=''><option selected=''></option></select>",e.querySelectorAll("[msallowcapture^='']").length&&v.push("[*^$]="+M+"*(?:''|\"\")"),e.querySelectorAll("[selected]").length||v.push("\\["+M+"*(?:value|"+R+")"),e.querySelectorAll("[id~="+S+"-]").length||v.push("~="),(t=C.createElement("input")).setAttribute("name",""),e.appendChild(t),e.querySelectorAll("[name='']").length||v.push("\\["+M+"*name"+M+"*="+M+"*(?:''|\"\")"),e.querySelectorAll(":checked").length||v.push(":checked"),e.querySelectorAll("a#"+S+"+*").length||v.push(".#.+[+~]"),e.querySelectorAll("\\\f"),v.push("[\\r\\n\\f]")}),ce(function(e){e.innerHTML="<a href='' disabled='disabled'></a><select disabled='disabled'><option/></select>";var t=C.createElement("input");t.setAttribute("type","hidden"),e.appendChild(t).setAttribute("name","D"),e.querySelectorAll("[name=d]").length&&v.push("name"+M+"*[*^$|!~]?="),2!==e.querySelectorAll(":enabled").length&&v.push(":enabled",":disabled"),a.appendChild(e).disabled=!0,2!==e.querySelectorAll(":disabled").length&&v.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),v.push(",.*:")})),(d.matchesSelector=K.test(c=a.matches||a.webkitMatchesSelector||a.mozMatchesSelector||a.oMatchesSelector||a.msMatchesSelector))&&ce(function(e){d.disconnectedMatch=c.call(e,"*"),c.call(e,"[s!='']:x"),s.push("!=",F)}),v=v.length&&new RegExp(v.join("|")),s=s.length&&new RegExp(s.join("|")),t=K.test(a.compareDocumentPosition),y=t||K.test(a.contains)?function(e,t){var n=9===e.nodeType?e.documentElement:e,r=t&&t.parentNode;return e===r||!(!r||1!==r.nodeType||!(n.contains?n.contains(r):e.compareDocumentPosition&&16&e.compareDocumentPosition(r)))}:function(e,t){if(t)while(t=t.parentNode)if(t===e)return!0;return!1},D=t?function(e,t){if(e===t)return l=!0,0;var n=!e.compareDocumentPosition-!t.compareDocumentPosition;return n||(1&(n=(e.ownerDocument||e)==(t.ownerDocument||t)?e.compareDocumentPosition(t):1)||!d.sortDetached&&t.compareDocumentPosition(e)===n?e==C||e.ownerDocument==p&&y(p,e)?-1:t==C||t.ownerDocument==p&&y(p,t)?1:u?P(u,e)-P(u,t):0:4&n?-1:1)}:function(e,t){if(e===t)return l=!0,0;var n,r=0,i=e.parentNode,o=t.parentNode,a=[e],s=[t];if(!i||!o)return e==C?-1:t==C?1:i?-1:o?1:u?P(u,e)-P(u,t):0;if(i===o)return pe(e,t);n=e;while(n=n.parentNode)a.unshift(n);n=t;while(n=n.parentNode)s.unshift(n);while(a[r]===s[r])r++;return r?pe(a[r],s[r]):a[r]==p?-1:s[r]==p?1:0}),C},se.matches=function(e,t){return se(e,null,null,t)},se.matchesSelector=function(e,t){if(T(e),d.matchesSelector&&E&&!N[t+" "]&&(!s||!s.test(t))&&(!v||!v.test(t)))try{var n=c.call(e,t);if(n||d.disconnectedMatch||e.document&&11!==e.document.nodeType)return n}catch(e){N(t,!0)}return 0<se(t,C,null,[e]).length},se.contains=function(e,t){return(e.ownerDocument||e)!=C&&T(e),y(e,t)},se.attr=function(e,t){(e.ownerDocument||e)!=C&&T(e);var n=b.attrHandle[t.toLowerCase()],r=n&&j.call(b.attrHandle,t.toLowerCase())?n(e,t,!E):void 0;return void 0!==r?r:d.attributes||!E?e.getAttribute(t):(r=e.getAttributeNode(t))&&r.specified?r.value:null},se.escape=function(e){return(e+"").replace(re,ie)},se.error=function(e){throw new Error("Syntax error, unrecognized expression: "+e)},se.uniqueSort=function(e){var t,n=[],r=0,i=0;if(l=!d.detectDuplicates,u=!d.sortStable&&e.slice(0),e.sort(D),l){while(t=e[i++])t===e[i]&&(r=n.push(i));while(r--)e.splice(n[r],1)}return u=null,e},o=se.getText=function(e){var t,n="",r=0,i=e.nodeType;if(i){if(1===i||9===i||11===i){if("string"==typeof e.textContent)return e.textContent;for(e=e.firstChild;e;e=e.nextSibling)n+=o(e)}else if(3===i||4===i)return e.nodeValue}else while(t=e[r++])n+=o(t);return n},(b=se.selectors={cacheLength:50,createPseudo:le,match:G,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(te,ne),e[3]=(e[3]||e[4]||e[5]||"").replace(te,ne),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||se.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&se.error(e[0]),e},PSEUDO:function(e){var t,n=!e[6]&&e[2];return G.CHILD.test(e[0])?null:(e[3]?e[2]=e[4]||e[5]||"":n&&X.test(n)&&(t=h(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(te,ne).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=m[e+" "];return t||(t=new RegExp("(^|"+M+")"+e+"("+M+"|$)"))&&m(e,function(e){return t.test("string"==typeof e.className&&e.className||"undefined"!=typeof e.getAttribute&&e.getAttribute("class")||"")})},ATTR:function(n,r,i){return function(e){var t=se.attr(e,n);return null==t?"!="===r:!r||(t+="","="===r?t===i:"!="===r?t!==i:"^="===r?i&&0===t.indexOf(i):"*="===r?i&&-1<t.indexOf(i):"$="===r?i&&t.slice(-i.length)===i:"~="===r?-1<(" "+t.replace(B," ")+" ").indexOf(i):"|="===r&&(t===i||t.slice(0,i.length+1)===i+"-"))}},CHILD:function(h,e,t,g,v){var y="nth"!==h.slice(0,3),m="last"!==h.slice(-4),x="of-type"===e;return 1===g&&0===v?function(e){return!!e.parentNode}:function(e,t,n){var r,i,o,a,s,u,l=y!==m?"nextSibling":"previousSibling",c=e.parentNode,f=x&&e.nodeName.toLowerCase(),p=!n&&!x,d=!1;if(c){if(y){while(l){a=e;while(a=a[l])if(x?a.nodeName.toLowerCase()===f:1===a.nodeType)return!1;u=l="only"===h&&!u&&"nextSibling"}return!0}if(u=[m?c.firstChild:c.lastChild],m&&p){d=(s=(r=(i=(o=(a=c)[S]||(a[S]={}))[a.uniqueID]||(o[a.uniqueID]={}))[h]||[])[0]===k&&r[1])&&r[2],a=s&&c.childNodes[s];while(a=++s&&a&&a[l]||(d=s=0)||u.pop())if(1===a.nodeType&&++d&&a===e){i[h]=[k,s,d];break}}else if(p&&(d=s=(r=(i=(o=(a=e)[S]||(a[S]={}))[a.uniqueID]||(o[a.uniqueID]={}))[h]||[])[0]===k&&r[1]),!1===d)while(a=++s&&a&&a[l]||(d=s=0)||u.pop())if((x?a.nodeName.toLowerCase()===f:1===a.nodeType)&&++d&&(p&&((i=(o=a[S]||(a[S]={}))[a.uniqueID]||(o[a.uniqueID]={}))[h]=[k,d]),a===e))break;return(d-=v)===g||d%g==0&&0<=d/g}}},PSEUDO:function(e,o){var t,a=b.pseudos[e]||b.setFilters[e.toLowerCase()]||se.error("unsupported pseudo: "+e);return a[S]?a(o):1<a.length?(t=[e,e,"",o],b.setFilters.hasOwnProperty(e.toLowerCase())?le(function(e,t){var n,r=a(e,o),i=r.length;while(i--)e[n=P(e,r[i])]=!(t[n]=r[i])}):function(e){return a(e,0,t)}):a}},pseudos:{not:le(function(e){var r=[],i=[],s=f(e.replace($,"$1"));return s[S]?le(function(e,t,n,r){var i,o=s(e,null,r,[]),a=e.length;while(a--)(i=o[a])&&(e[a]=!(t[a]=i))}):function(e,t,n){return r[0]=e,s(r,null,n,i),r[0]=null,!i.pop()}}),has:le(function(t){return function(e){return 0<se(t,e).length}}),contains:le(function(t){return t=t.replace(te,ne),function(e){return-1<(e.textContent||o(e)).indexOf(t)}}),lang:le(function(n){return V.test(n||"")||se.error("unsupported lang: "+n),n=n.replace(te,ne).toLowerCase(),function(e){var t;do{if(t=E?e.lang:e.getAttribute("xml:lang")||e.getAttribute("lang"))return(t=t.toLowerCase())===n||0===t.indexOf(n+"-")}while((e=e.parentNode)&&1===e.nodeType);return!1}}),target:function(e){var t=n.location&&n.location.hash;return t&&t.slice(1)===e.id},root:function(e){return e===a},focus:function(e){return e===C.activeElement&&(!C.hasFocus||C.hasFocus())&&!!(e.type||e.href||~e.tabIndex)},enabled:ge(!1),disabled:ge(!0),checked:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&!!e.checked||"option"===t&&!!e.selected},selected:function(e){return e.parentNode&&e.parentNode.selectedIndex,!0===e.selected},empty:function(e){for(e=e.firstChild;e;e=e.nextSibling)if(e.nodeType<6)return!1;return!0},parent:function(e){return!b.pseudos.empty(e)},header:function(e){return J.test(e.nodeName)},input:function(e){return Q.test(e.nodeName)},button:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&"button"===e.type||"button"===t},text:function(e){var t;return"input"===e.nodeName.toLowerCase()&&"text"===e.type&&(null==(t=e.getAttribute("type"))||"text"===t.toLowerCase())},first:ve(function(){return[0]}),last:ve(function(e,t){return[t-1]}),eq:ve(function(e,t,n){return[n<0?n+t:n]}),even:ve(function(e,t){for(var n=0;n<t;n+=2)e.push(n);return e}),odd:ve(function(e,t){for(var n=1;n<t;n+=2)e.push(n);return e}),lt:ve(function(e,t,n){for(var r=n<0?n+t:t<n?t:n;0<=--r;)e.push(r);return e}),gt:ve(function(e,t,n){for(var r=n<0?n+t:n;++r<t;)e.push(r);return e})}}).pseudos.nth=b.pseudos.eq,{radio:!0,checkbox:!0,file:!0,password:!0,image:!0})b.pseudos[e]=de(e);for(e in{submit:!0,reset:!0})b.pseudos[e]=he(e);function me(){}function xe(e){for(var t=0,n=e.length,r="";t<n;t++)r+=e[t].value;return r}function be(s,e,t){var u=e.dir,l=e.next,c=l||u,f=t&&"parentNode"===c,p=r++;return e.first?function(e,t,n){while(e=e[u])if(1===e.nodeType||f)return s(e,t,n);return!1}:function(e,t,n){var r,i,o,a=[k,p];if(n){while(e=e[u])if((1===e.nodeType||f)&&s(e,t,n))return!0}else while(e=e[u])if(1===e.nodeType||f)if(i=(o=e[S]||(e[S]={}))[e.uniqueID]||(o[e.uniqueID]={}),l&&l===e.nodeName.toLowerCase())e=e[u]||e;else{if((r=i[c])&&r[0]===k&&r[1]===p)return a[2]=r[2];if((i[c]=a)[2]=s(e,t,n))return!0}return!1}}function we(i){return 1<i.length?function(e,t,n){var r=i.length;while(r--)if(!i[r](e,t,n))return!1;return!0}:i[0]}function Te(e,t,n,r,i){for(var o,a=[],s=0,u=e.length,l=null!=t;s<u;s++)(o=e[s])&&(n&&!n(o,r,i)||(a.push(o),l&&t.push(s)));return a}function Ce(d,h,g,v,y,e){return v&&!v[S]&&(v=Ce(v)),y&&!y[S]&&(y=Ce(y,e)),le(function(e,t,n,r){var i,o,a,s=[],u=[],l=t.length,c=e||function(e,t,n){for(var r=0,i=t.length;r<i;r++)se(e,t[r],n);return n}(h||"*",n.nodeType?[n]:n,[]),f=!d||!e&&h?c:Te(c,s,d,n,r),p=g?y||(e?d:l||v)?[]:t:f;if(g&&g(f,p,n,r),v){i=Te(p,u),v(i,[],n,r),o=i.length;while(o--)(a=i[o])&&(p[u[o]]=!(f[u[o]]=a))}if(e){if(y||d){if(y){i=[],o=p.length;while(o--)(a=p[o])&&i.push(f[o]=a);y(null,p=[],i,r)}o=p.length;while(o--)(a=p[o])&&-1<(i=y?P(e,a):s[o])&&(e[i]=!(t[i]=a))}}else p=Te(p===t?p.splice(l,p.length):p),y?y(null,t,p,r):H.apply(t,p)})}function Ee(e){for(var i,t,n,r=e.length,o=b.relative[e[0].type],a=o||b.relative[" "],s=o?1:0,u=be(function(e){return e===i},a,!0),l=be(function(e){return-1<P(i,e)},a,!0),c=[function(e,t,n){var r=!o&&(n||t!==w)||((i=t).nodeType?u(e,t,n):l(e,t,n));return i=null,r}];s<r;s++)if(t=b.relative[e[s].type])c=[be(we(c),t)];else{if((t=b.filter[e[s].type].apply(null,e[s].matches))[S]){for(n=++s;n<r;n++)if(b.relative[e[n].type])break;return Ce(1<s&&we(c),1<s&&xe(e.slice(0,s-1).concat({value:" "===e[s-2].type?"*":""})).replace($,"$1"),t,s<n&&Ee(e.slice(s,n)),n<r&&Ee(e=e.slice(n)),n<r&&xe(e))}c.push(t)}return we(c)}return me.prototype=b.filters=b.pseudos,b.setFilters=new me,h=se.tokenize=function(e,t){var n,r,i,o,a,s,u,l=x[e+" "];if(l)return t?0:l.slice(0);a=e,s=[],u=b.preFilter;while(a){for(o in n&&!(r=_.exec(a))||(r&&(a=a.slice(r[0].length)||a),s.push(i=[])),n=!1,(r=z.exec(a))&&(n=r.shift(),i.push({value:n,type:r[0].replace($," ")}),a=a.slice(n.length)),b.filter)!(r=G[o].exec(a))||u[o]&&!(r=u[o](r))||(n=r.shift(),i.push({value:n,type:o,matches:r}),a=a.slice(n.length));if(!n)break}return t?a.length:a?se.error(e):x(e,s).slice(0)},f=se.compile=function(e,t){var n,v,y,m,x,r,i=[],o=[],a=A[e+" "];if(!a){t||(t=h(e)),n=t.length;while(n--)(a=Ee(t[n]))[S]?i.push(a):o.push(a);(a=A(e,(v=o,m=0<(y=i).length,x=0<v.length,r=function(e,t,n,r,i){var o,a,s,u=0,l="0",c=e&&[],f=[],p=w,d=e||x&&b.find.TAG("*",i),h=k+=null==p?1:Math.random()||.1,g=d.length;for(i&&(w=t==C||t||i);l!==g&&null!=(o=d[l]);l++){if(x&&o){a=0,t||o.ownerDocument==C||(T(o),n=!E);while(s=v[a++])if(s(o,t||C,n)){r.push(o);break}i&&(k=h)}m&&((o=!s&&o)&&u--,e&&c.push(o))}if(u+=l,m&&l!==u){a=0;while(s=y[a++])s(c,f,t,n);if(e){if(0<u)while(l--)c[l]||f[l]||(f[l]=q.call(r));f=Te(f)}H.apply(r,f),i&&!e&&0<f.length&&1<u+y.length&&se.uniqueSort(r)}return i&&(k=h,w=p),c},m?le(r):r))).selector=e}return a},g=se.select=function(e,t,n,r){var i,o,a,s,u,l="function"==typeof e&&e,c=!r&&h(e=l.selector||e);if(n=n||[],1===c.length){if(2<(o=c[0]=c[0].slice(0)).length&&"ID"===(a=o[0]).type&&9===t.nodeType&&E&&b.relative[o[1].type]){if(!(t=(b.find.ID(a.matches[0].replace(te,ne),t)||[])[0]))return n;l&&(t=t.parentNode),e=e.slice(o.shift().value.length)}i=G.needsContext.test(e)?0:o.length;while(i--){if(a=o[i],b.relative[s=a.type])break;if((u=b.find[s])&&(r=u(a.matches[0].replace(te,ne),ee.test(o[0].type)&&ye(t.parentNode)||t))){if(o.splice(i,1),!(e=r.length&&xe(o)))return H.apply(n,r),n;break}}}return(l||f(e,c))(r,t,!E,n,!t||ee.test(e)&&ye(t.parentNode)||t),n},d.sortStable=S.split("").sort(D).join("")===S,d.detectDuplicates=!!l,T(),d.sortDetached=ce(function(e){return 1&e.compareDocumentPosition(C.createElement("fieldset"))}),ce(function(e){return e.innerHTML="<a href='#'></a>","#"===e.firstChild.getAttribute("href")})||fe("type|href|height|width",function(e,t,n){if(!n)return e.getAttribute(t,"type"===t.toLowerCase()?1:2)}),d.attributes&&ce(function(e){return e.innerHTML="<input/>",e.firstChild.setAttribute("value",""),""===e.firstChild.getAttribute("value")})||fe("value",function(e,t,n){if(!n&&"input"===e.nodeName.toLowerCase())return e.defaultValue}),ce(function(e){return null==e.getAttribute("disabled")})||fe(R,function(e,t,n){var r;if(!n)return!0===e[t]?t.toLowerCase():(r=e.getAttributeNode(t))&&r.specified?r.value:null}),se}(C);S.find=d,S.expr=d.selectors,S.expr[":"]=S.expr.pseudos,S.uniqueSort=S.unique=d.uniqueSort,S.text=d.getText,S.isXMLDoc=d.isXML,S.contains=d.contains,S.escapeSelector=d.escape;var h=function(e,t,n){var r=[],i=void 0!==n;while((e=e[t])&&9!==e.nodeType)if(1===e.nodeType){if(i&&S(e).is(n))break;r.push(e)}return r},T=function(e,t){for(var n=[];e;e=e.nextSibling)1===e.nodeType&&e!==t&&n.push(e);return n},k=S.expr.match.needsContext;function A(e,t){return e.nodeName&&e.nodeName.toLowerCase()===t.toLowerCase()}var N=/^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;function D(e,n,r){return m(n)?S.grep(e,function(e,t){return!!n.call(e,t,e)!==r}):n.nodeType?S.grep(e,function(e){return e===n!==r}):"string"!=typeof n?S.grep(e,function(e){return-1<i.call(n,e)!==r}):S.filter(n,e,r)}S.filter=function(e,t,n){var r=t[0];return n&&(e=":not("+e+")"),1===t.length&&1===r.nodeType?S.find.matchesSelector(r,e)?[r]:[]:S.find.matches(e,S.grep(t,function(e){return 1===e.nodeType}))},S.fn.extend({find:function(e){var t,n,r=this.length,i=this;if("string"!=typeof e)return this.pushStack(S(e).filter(function(){for(t=0;t<r;t++)if(S.contains(i[t],this))return!0}));for(n=this.pushStack([]),t=0;t<r;t++)S.find(e,i[t],n);return 1<r?S.uniqueSort(n):n},filter:function(e){return this.pushStack(D(this,e||[],!1))},not:function(e){return this.pushStack(D(this,e||[],!0))},is:function(e){return!!D(this,"string"==typeof e&&k.test(e)?S(e):e||[],!1).length}});var j,q=/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/;(S.fn.init=function(e,t,n){var r,i;if(!e)return this;if(n=n||j,"string"==typeof e){if(!(r="<"===e[0]&&">"===e[e.length-1]&&3<=e.length?[null,e,null]:q.exec(e))||!r[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(r[1]){if(t=t instanceof S?t[0]:t,S.merge(this,S.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:E,!0)),N.test(r[1])&&S.isPlainObject(t))for(r in t)m(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return(i=E.getElementById(r[2]))&&(this[0]=i,this.length=1),this}return e.nodeType?(this[0]=e,this.length=1,this):m(e)?void 0!==n.ready?n.ready(e):e(S):S.makeArray(e,this)}).prototype=S.fn,j=S(E);var L=/^(?:parents|prev(?:Until|All))/,H={children:!0,contents:!0,next:!0,prev:!0};function O(e,t){while((e=e[t])&&1!==e.nodeType);return e}S.fn.extend({has:function(e){var t=S(e,this),n=t.length;return this.filter(function(){for(var e=0;e<n;e++)if(S.contains(this,t[e]))return!0})},closest:function(e,t){var n,r=0,i=this.length,o=[],a="string"!=typeof e&&S(e);if(!k.test(e))for(;r<i;r++)for(n=this[r];n&&n!==t;n=n.parentNode)if(n.nodeType<11&&(a?-1<a.index(n):1===n.nodeType&&S.find.matchesSelector(n,e))){o.push(n);break}return this.pushStack(1<o.length?S.uniqueSort(o):o)},index:function(e){return e?"string"==typeof e?i.call(S(e),this[0]):i.call(this,e.jquery?e[0]:e):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(e,t){return this.pushStack(S.uniqueSort(S.merge(this.get(),S(e,t))))},addBack:function(e){return this.add(null==e?this.prevObject:this.prevObject.filter(e))}}),S.each({parent:function(e){var t=e.parentNode;return t&&11!==t.nodeType?t:null},parents:function(e){return h(e,"parentNode")},parentsUntil:function(e,t,n){return h(e,"parentNode",n)},next:function(e){return O(e,"nextSibling")},prev:function(e){return O(e,"previousSibling")},nextAll:function(e){return h(e,"nextSibling")},prevAll:function(e){return h(e,"previousSibling")},nextUntil:function(e,t,n){return h(e,"nextSibling",n)},prevUntil:function(e,t,n){return h(e,"previousSibling",n)},siblings:function(e){return T((e.parentNode||{}).firstChild,e)},children:function(e){return T(e.firstChild)},contents:function(e){return null!=e.contentDocument&&r(e.contentDocument)?e.contentDocument:(A(e,"template")&&(e=e.content||e),S.merge([],e.childNodes))}},function(r,i){S.fn[r]=function(e,t){var n=S.map(this,i,e);return"Until"!==r.slice(-5)&&(t=e),t&&"string"==typeof t&&(n=S.filter(t,n)),1<this.length&&(H[r]||S.uniqueSort(n),L.test(r)&&n.reverse()),this.pushStack(n)}});var P=/[^\x20\t\r\n\f]+/g;function R(e){return e}function M(e){throw e}function I(e,t,n,r){var i;try{e&&m(i=e.promise)?i.call(e).done(t).fail(n):e&&m(i=e.then)?i.call(e,t,n):t.apply(void 0,[e].slice(r))}catch(e){n.apply(void 0,[e])}}S.Callbacks=function(r){var e,n;r="string"==typeof r?(e=r,n={},S.each(e.match(P)||[],function(e,t){n[t]=!0}),n):S.extend({},r);var i,t,o,a,s=[],u=[],l=-1,c=function(){for(a=a||r.once,o=i=!0;u.length;l=-1){t=u.shift();while(++l<s.length)!1===s[l].apply(t[0],t[1])&&r.stopOnFalse&&(l=s.length,t=!1)}r.memory||(t=!1),i=!1,a&&(s=t?[]:"")},f={add:function(){return s&&(t&&!i&&(l=s.length-1,u.push(t)),function n(e){S.each(e,function(e,t){m(t)?r.unique&&f.has(t)||s.push(t):t&&t.length&&"string"!==w(t)&&n(t)})}(arguments),t&&!i&&c()),this},remove:function(){return S.each(arguments,function(e,t){var n;while(-1<(n=S.inArray(t,s,n)))s.splice(n,1),n<=l&&l--}),this},has:function(e){return e?-1<S.inArray(e,s):0<s.length},empty:function(){return s&&(s=[]),this},disable:function(){return a=u=[],s=t="",this},disabled:function(){return!s},lock:function(){return a=u=[],t||i||(s=t=""),this},locked:function(){return!!a},fireWith:function(e,t){return a||(t=[e,(t=t||[]).slice?t.slice():t],u.push(t),i||c()),this},fire:function(){return f.fireWith(this,arguments),this},fired:function(){return!!o}};return f},S.extend({Deferred:function(e){var o=[["notify","progress",S.Callbacks("memory"),S.Callbacks("memory"),2],["resolve","done",S.Callbacks("once memory"),S.Callbacks("once memory"),0,"resolved"],["reject","fail",S.Callbacks("once memory"),S.Callbacks("once memory"),1,"rejected"]],i="pending",a={state:function(){return i},always:function(){return s.done(arguments).fail(arguments),this},"catch":function(e){return a.then(null,e)},pipe:function(){var i=arguments;return S.Deferred(function(r){S.each(o,function(e,t){var n=m(i[t[4]])&&i[t[4]];s[t[1]](function(){var e=n&&n.apply(this,arguments);e&&m(e.promise)?e.promise().progress(r.notify).done(r.resolve).fail(r.reject):r[t[0]+"With"](this,n?[e]:arguments)})}),i=null}).promise()},then:function(t,n,r){var u=0;function l(i,o,a,s){return function(){var n=this,r=arguments,e=function(){var e,t;if(!(i<u)){if((e=a.apply(n,r))===o.promise())throw new TypeError("Thenable self-resolution");t=e&&("object"==typeof e||"function"==typeof e)&&e.then,m(t)?s?t.call(e,l(u,o,R,s),l(u,o,M,s)):(u++,t.call(e,l(u,o,R,s),l(u,o,M,s),l(u,o,R,o.notifyWith))):(a!==R&&(n=void 0,r=[e]),(s||o.resolveWith)(n,r))}},t=s?e:function(){try{e()}catch(e){S.Deferred.exceptionHook&&S.Deferred.exceptionHook(e,t.stackTrace),u<=i+1&&(a!==M&&(n=void 0,r=[e]),o.rejectWith(n,r))}};i?t():(S.Deferred.getStackHook&&(t.stackTrace=S.Deferred.getStackHook()),C.setTimeout(t))}}return S.Deferred(function(e){o[0][3].add(l(0,e,m(r)?r:R,e.notifyWith)),o[1][3].add(l(0,e,m(t)?t:R)),o[2][3].add(l(0,e,m(n)?n:M))}).promise()},promise:function(e){return null!=e?S.extend(e,a):a}},s={};return S.each(o,function(e,t){var n=t[2],r=t[5];a[t[1]]=n.add,r&&n.add(function(){i=r},o[3-e][2].disable,o[3-e][3].disable,o[0][2].lock,o[0][3].lock),n.add(t[3].fire),s[t[0]]=function(){return s[t[0]+"With"](this===s?void 0:this,arguments),this},s[t[0]+"With"]=n.fireWith}),a.promise(s),e&&e.call(s,s),s},when:function(e){var n=arguments.length,t=n,r=Array(t),i=s.call(arguments),o=S.Deferred(),a=function(t){return function(e){r[t]=this,i[t]=1<arguments.length?s.call(arguments):e,--n||o.resolveWith(r,i)}};if(n<=1&&(I(e,o.done(a(t)).resolve,o.reject,!n),"pending"===o.state()||m(i[t]&&i[t].then)))return o.then();while(t--)I(i[t],a(t),o.reject);return o.promise()}});var W=/^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;S.Deferred.exceptionHook=function(e,t){C.console&&C.console.warn&&e&&W.test(e.name)&&C.console.warn("jQuery.Deferred exception: "+e.message,e.stack,t)},S.readyException=function(e){C.setTimeout(function(){throw e})};var F=S.Deferred();function B(){E.removeEventListener("DOMContentLoaded",B),C.removeEventListener("load",B),S.ready()}S.fn.ready=function(e){return F.then(e)["catch"](function(e){S.readyException(e)}),this},S.extend({isReady:!1,readyWait:1,ready:function(e){(!0===e?--S.readyWait:S.isReady)||(S.isReady=!0)!==e&&0<--S.readyWait||F.resolveWith(E,[S])}}),S.ready.then=F.then,"complete"===E.readyState||"loading"!==E.readyState&&!E.documentElement.doScroll?C.setTimeout(S.ready):(E.addEventListener("DOMContentLoaded",B),C.addEventListener("load",B));var $=function(e,t,n,r,i,o,a){var s=0,u=e.length,l=null==n;if("object"===w(n))for(s in i=!0,n)$(e,t,s,n[s],!0,o,a);else if(void 0!==r&&(i=!0,m(r)||(a=!0),l&&(a?(t.call(e,r),t=null):(l=t,t=function(e,t,n){return l.call(S(e),n)})),t))for(;s<u;s++)t(e[s],n,a?r:r.call(e[s],s,t(e[s],n)));return i?e:l?t.call(e):u?t(e[0],n):o},_=/^-ms-/,z=/-([a-z])/g;function U(e,t){return t.toUpperCase()}function X(e){return e.replace(_,"ms-").replace(z,U)}var V=function(e){return 1===e.nodeType||9===e.nodeType||!+e.nodeType};function G(){this.expando=S.expando+G.uid++}G.uid=1,G.prototype={cache:function(e){var t=e[this.expando];return t||(t={},V(e)&&(e.nodeType?e[this.expando]=t:Object.defineProperty(e,this.expando,{value:t,configurable:!0}))),t},set:function(e,t,n){var r,i=this.cache(e);if("string"==typeof t)i[X(t)]=n;else for(r in t)i[X(r)]=t[r];return i},get:function(e,t){return void 0===t?this.cache(e):e[this.expando]&&e[this.expando][X(t)]},access:function(e,t,n){return void 0===t||t&&"string"==typeof t&&void 0===n?this.get(e,t):(this.set(e,t,n),void 0!==n?n:t)},remove:function(e,t){var n,r=e[this.expando];if(void 0!==r){if(void 0!==t){n=(t=Array.isArray(t)?t.map(X):(t=X(t))in r?[t]:t.match(P)||[]).length;while(n--)delete r[t[n]]}(void 0===t||S.isEmptyObject(r))&&(e.nodeType?e[this.expando]=void 0:delete e[this.expando])}},hasData:function(e){var t=e[this.expando];return void 0!==t&&!S.isEmptyObject(t)}};var Y=new G,Q=new G,J=/^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,K=/[A-Z]/g;function Z(e,t,n){var r,i;if(void 0===n&&1===e.nodeType)if(r="data-"+t.replace(K,"-$&").toLowerCase(),"string"==typeof(n=e.getAttribute(r))){try{n="true"===(i=n)||"false"!==i&&("null"===i?null:i===+i+""?+i:J.test(i)?JSON.parse(i):i)}catch(e){}Q.set(e,t,n)}else n=void 0;return n}S.extend({hasData:function(e){return Q.hasData(e)||Y.hasData(e)},data:function(e,t,n){return Q.access(e,t,n)},removeData:function(e,t){Q.remove(e,t)},_data:function(e,t,n){return Y.access(e,t,n)},_removeData:function(e,t){Y.remove(e,t)}}),S.fn.extend({data:function(n,e){var t,r,i,o=this[0],a=o&&o.attributes;if(void 0===n){if(this.length&&(i=Q.get(o),1===o.nodeType&&!Y.get(o,"hasDataAttrs"))){t=a.length;while(t--)a[t]&&0===(r=a[t].name).indexOf("data-")&&(r=X(r.slice(5)),Z(o,r,i[r]));Y.set(o,"hasDataAttrs",!0)}return i}return"object"==typeof n?this.each(function(){Q.set(this,n)}):$(this,function(e){var t;if(o&&void 0===e)return void 0!==(t=Q.get(o,n))?t:void 0!==(t=Z(o,n))?t:void 0;this.each(function(){Q.set(this,n,e)})},null,e,1<arguments.length,null,!0)},removeData:function(e){return this.each(function(){Q.remove(this,e)})}}),S.extend({queue:function(e,t,n){var r;if(e)return t=(t||"fx")+"queue",r=Y.get(e,t),n&&(!r||Array.isArray(n)?r=Y.access(e,t,S.makeArray(n)):r.push(n)),r||[]},dequeue:function(e,t){t=t||"fx";var n=S.queue(e,t),r=n.length,i=n.shift(),o=S._queueHooks(e,t);"inprogress"===i&&(i=n.shift(),r--),i&&("fx"===t&&n.unshift("inprogress"),delete o.stop,i.call(e,function(){S.dequeue(e,t)},o)),!r&&o&&o.empty.fire()},_queueHooks:function(e,t){var n=t+"queueHooks";return Y.get(e,n)||Y.access(e,n,{empty:S.Callbacks("once memory").add(function(){Y.remove(e,[t+"queue",n])})})}}),S.fn.extend({queue:function(t,n){var e=2;return"string"!=typeof t&&(n=t,t="fx",e--),arguments.length<e?S.queue(this[0],t):void 0===n?this:this.each(function(){var e=S.queue(this,t,n);S._queueHooks(this,t),"fx"===t&&"inprogress"!==e[0]&&S.dequeue(this,t)})},dequeue:function(e){return this.each(function(){S.dequeue(this,e)})},clearQueue:function(e){return this.queue(e||"fx",[])},promise:function(e,t){var n,r=1,i=S.Deferred(),o=this,a=this.length,s=function(){--r||i.resolveWith(o,[o])};"string"!=typeof e&&(t=e,e=void 0),e=e||"fx";while(a--)(n=Y.get(o[a],e+"queueHooks"))&&n.empty&&(r++,n.empty.add(s));return s(),i.promise(t)}});var ee=/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,te=new RegExp("^(?:([+-])=|)("+ee+")([a-z%]*)$","i"),ne=["Top","Right","Bottom","Left"],re=E.documentElement,ie=function(e){return S.contains(e.ownerDocument,e)},oe={composed:!0};re.getRootNode&&(ie=function(e){return S.contains(e.ownerDocument,e)||e.getRootNode(oe)===e.ownerDocument});var ae=function(e,t){return"none"===(e=t||e).style.display||""===e.style.display&&ie(e)&&"none"===S.css(e,"display")};function se(e,t,n,r){var i,o,a=20,s=r?function(){return r.cur()}:function(){return S.css(e,t,"")},u=s(),l=n&&n[3]||(S.cssNumber[t]?"":"px"),c=e.nodeType&&(S.cssNumber[t]||"px"!==l&&+u)&&te.exec(S.css(e,t));if(c&&c[3]!==l){u/=2,l=l||c[3],c=+u||1;while(a--)S.style(e,t,c+l),(1-o)*(1-(o=s()/u||.5))<=0&&(a=0),c/=o;c*=2,S.style(e,t,c+l),n=n||[]}return n&&(c=+c||+u||0,i=n[1]?c+(n[1]+1)*n[2]:+n[2],r&&(r.unit=l,r.start=c,r.end=i)),i}var ue={};function le(e,t){for(var n,r,i,o,a,s,u,l=[],c=0,f=e.length;c<f;c++)(r=e[c]).style&&(n=r.style.display,t?("none"===n&&(l[c]=Y.get(r,"display")||null,l[c]||(r.style.display="")),""===r.style.display&&ae(r)&&(l[c]=(u=a=o=void 0,a=(i=r).ownerDocument,s=i.nodeName,(u=ue[s])||(o=a.body.appendChild(a.createElement(s)),u=S.css(o,"display"),o.parentNode.removeChild(o),"none"===u&&(u="block"),ue[s]=u)))):"none"!==n&&(l[c]="none",Y.set(r,"display",n)));for(c=0;c<f;c++)null!=l[c]&&(e[c].style.display=l[c]);return e}S.fn.extend({show:function(){return le(this,!0)},hide:function(){return le(this)},toggle:function(e){return"boolean"==typeof e?e?this.show():this.hide():this.each(function(){ae(this)?S(this).show():S(this).hide()})}});var ce,fe,pe=/^(?:checkbox|radio)$/i,de=/<([a-z][^\/\0>\x20\t\r\n\f]*)/i,he=/^$|^module$|\/(?:java|ecma)script/i;ce=E.createDocumentFragment().appendChild(E.createElement("div")),(fe=E.createElement("input")).setAttribute("type","radio"),fe.setAttribute("checked","checked"),fe.setAttribute("name","t"),ce.appendChild(fe),y.checkClone=ce.cloneNode(!0).cloneNode(!0).lastChild.checked,ce.innerHTML="<textarea>x</textarea>",y.noCloneChecked=!!ce.cloneNode(!0).lastChild.defaultValue,ce.innerHTML="<option></option>",y.option=!!ce.lastChild;var ge={thead:[1,"<table>","</table>"],col:[2,"<table><colgroup>","</colgroup></table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],_default:[0,"",""]};function ve(e,t){var n;return n="undefined"!=typeof e.getElementsByTagName?e.getElementsByTagName(t||"*"):"undefined"!=typeof e.querySelectorAll?e.querySelectorAll(t||"*"):[],void 0===t||t&&A(e,t)?S.merge([e],n):n}function ye(e,t){for(var n=0,r=e.length;n<r;n++)Y.set(e[n],"globalEval",!t||Y.get(t[n],"globalEval"))}ge.tbody=ge.tfoot=ge.colgroup=ge.caption=ge.thead,ge.th=ge.td,y.option||(ge.optgroup=ge.option=[1,"<select multiple='multiple'>","</select>"]);var me=/<|&#?\w+;/;function xe(e,t,n,r,i){for(var o,a,s,u,l,c,f=t.createDocumentFragment(),p=[],d=0,h=e.length;d<h;d++)if((o=e[d])||0===o)if("object"===w(o))S.merge(p,o.nodeType?[o]:o);else if(me.test(o)){a=a||f.appendChild(t.createElement("div")),s=(de.exec(o)||["",""])[1].toLowerCase(),u=ge[s]||ge._default,a.innerHTML=u[1]+S.htmlPrefilter(o)+u[2],c=u[0];while(c--)a=a.lastChild;S.merge(p,a.childNodes),(a=f.firstChild).textContent=""}else p.push(t.createTextNode(o));f.textContent="",d=0;while(o=p[d++])if(r&&-1<S.inArray(o,r))i&&i.push(o);else if(l=ie(o),a=ve(f.appendChild(o),"script"),l&&ye(a),n){c=0;while(o=a[c++])he.test(o.type||"")&&n.push(o)}return f}var be=/^key/,we=/^(?:mouse|pointer|contextmenu|drag|drop)|click/,Te=/^([^.]*)(?:\.(.+)|)/;function Ce(){return!0}function Ee(){return!1}function Se(e,t){return e===function(){try{return E.activeElement}catch(e){}}()==("focus"===t)}function ke(e,t,n,r,i,o){var a,s;if("object"==typeof t){for(s in"string"!=typeof n&&(r=r||n,n=void 0),t)ke(e,s,n,r,t[s],o);return e}if(null==r&&null==i?(i=n,r=n=void 0):null==i&&("string"==typeof n?(i=r,r=void 0):(i=r,r=n,n=void 0)),!1===i)i=Ee;else if(!i)return e;return 1===o&&(a=i,(i=function(e){return S().off(e),a.apply(this,arguments)}).guid=a.guid||(a.guid=S.guid++)),e.each(function(){S.event.add(this,t,i,r,n)})}function Ae(e,i,o){o?(Y.set(e,i,!1),S.event.add(e,i,{namespace:!1,handler:function(e){var t,n,r=Y.get(this,i);if(1&e.isTrigger&&this[i]){if(r.length)(S.event.special[i]||{}).delegateType&&e.stopPropagation();else if(r=s.call(arguments),Y.set(this,i,r),t=o(this,i),this[i](),r!==(n=Y.get(this,i))||t?Y.set(this,i,!1):n={},r!==n)return e.stopImmediatePropagation(),e.preventDefault(),n.value}else r.length&&(Y.set(this,i,{value:S.event.trigger(S.extend(r[0],S.Event.prototype),r.slice(1),this)}),e.stopImmediatePropagation())}})):void 0===Y.get(e,i)&&S.event.add(e,i,Ce)}S.event={global:{},add:function(t,e,n,r,i){var o,a,s,u,l,c,f,p,d,h,g,v=Y.get(t);if(V(t)){n.handler&&(n=(o=n).handler,i=o.selector),i&&S.find.matchesSelector(re,i),n.guid||(n.guid=S.guid++),(u=v.events)||(u=v.events=Object.create(null)),(a=v.handle)||(a=v.handle=function(e){return"undefined"!=typeof S&&S.event.triggered!==e.type?S.event.dispatch.apply(t,arguments):void 0}),l=(e=(e||"").match(P)||[""]).length;while(l--)d=g=(s=Te.exec(e[l])||[])[1],h=(s[2]||"").split(".").sort(),d&&(f=S.event.special[d]||{},d=(i?f.delegateType:f.bindType)||d,f=S.event.special[d]||{},c=S.extend({type:d,origType:g,data:r,handler:n,guid:n.guid,selector:i,needsContext:i&&S.expr.match.needsContext.test(i),namespace:h.join(".")},o),(p=u[d])||((p=u[d]=[]).delegateCount=0,f.setup&&!1!==f.setup.call(t,r,h,a)||t.addEventListener&&t.addEventListener(d,a)),f.add&&(f.add.call(t,c),c.handler.guid||(c.handler.guid=n.guid)),i?p.splice(p.delegateCount++,0,c):p.push(c),S.event.global[d]=!0)}},remove:function(e,t,n,r,i){var o,a,s,u,l,c,f,p,d,h,g,v=Y.hasData(e)&&Y.get(e);if(v&&(u=v.events)){l=(t=(t||"").match(P)||[""]).length;while(l--)if(d=g=(s=Te.exec(t[l])||[])[1],h=(s[2]||"").split(".").sort(),d){f=S.event.special[d]||{},p=u[d=(r?f.delegateType:f.bindType)||d]||[],s=s[2]&&new RegExp("(^|\\.)"+h.join("\\.(?:.*\\.|)")+"(\\.|$)"),a=o=p.length;while(o--)c=p[o],!i&&g!==c.origType||n&&n.guid!==c.guid||s&&!s.test(c.namespace)||r&&r!==c.selector&&("**"!==r||!c.selector)||(p.splice(o,1),c.selector&&p.delegateCount--,f.remove&&f.remove.call(e,c));a&&!p.length&&(f.teardown&&!1!==f.teardown.call(e,h,v.handle)||S.removeEvent(e,d,v.handle),delete u[d])}else for(d in u)S.event.remove(e,d+t[l],n,r,!0);S.isEmptyObject(u)&&Y.remove(e,"handle events")}},dispatch:function(e){var t,n,r,i,o,a,s=new Array(arguments.length),u=S.event.fix(e),l=(Y.get(this,"events")||Object.create(null))[u.type]||[],c=S.event.special[u.type]||{};for(s[0]=u,t=1;t<arguments.length;t++)s[t]=arguments[t];if(u.delegateTarget=this,!c.preDispatch||!1!==c.preDispatch.call(this,u)){a=S.event.handlers.call(this,u,l),t=0;while((i=a[t++])&&!u.isPropagationStopped()){u.currentTarget=i.elem,n=0;while((o=i.handlers[n++])&&!u.isImmediatePropagationStopped())u.rnamespace&&!1!==o.namespace&&!u.rnamespace.test(o.namespace)||(u.handleObj=o,u.data=o.data,void 0!==(r=((S.event.special[o.origType]||{}).handle||o.handler).apply(i.elem,s))&&!1===(u.result=r)&&(u.preventDefault(),u.stopPropagation()))}return c.postDispatch&&c.postDispatch.call(this,u),u.result}},handlers:function(e,t){var n,r,i,o,a,s=[],u=t.delegateCount,l=e.target;if(u&&l.nodeType&&!("click"===e.type&&1<=e.button))for(;l!==this;l=l.parentNode||this)if(1===l.nodeType&&("click"!==e.type||!0!==l.disabled)){for(o=[],a={},n=0;n<u;n++)void 0===a[i=(r=t[n]).selector+" "]&&(a[i]=r.needsContext?-1<S(i,this).index(l):S.find(i,this,null,[l]).length),a[i]&&o.push(r);o.length&&s.push({elem:l,handlers:o})}return l=this,u<t.length&&s.push({elem:l,handlers:t.slice(u)}),s},addProp:function(t,e){Object.defineProperty(S.Event.prototype,t,{enumerable:!0,configurable:!0,get:m(e)?function(){if(this.originalEvent)return e(this.originalEvent)}:function(){if(this.originalEvent)return this.originalEvent[t]},set:function(e){Object.defineProperty(this,t,{enumerable:!0,configurable:!0,writable:!0,value:e})}})},fix:function(e){return e[S.expando]?e:new S.Event(e)},special:{load:{noBubble:!0},click:{setup:function(e){var t=this||e;return pe.test(t.type)&&t.click&&A(t,"input")&&Ae(t,"click",Ce),!1},trigger:function(e){var t=this||e;return pe.test(t.type)&&t.click&&A(t,"input")&&Ae(t,"click"),!0},_default:function(e){var t=e.target;return pe.test(t.type)&&t.click&&A(t,"input")&&Y.get(t,"click")||A(t,"a")}},beforeunload:{postDispatch:function(e){void 0!==e.result&&e.originalEvent&&(e.originalEvent.returnValue=e.result)}}}},S.removeEvent=function(e,t,n){e.removeEventListener&&e.removeEventListener(t,n)},S.Event=function(e,t){if(!(this instanceof S.Event))return new S.Event(e,t);e&&e.type?(this.originalEvent=e,this.type=e.type,this.isDefaultPrevented=e.defaultPrevented||void 0===e.defaultPrevented&&!1===e.returnValue?Ce:Ee,this.target=e.target&&3===e.target.nodeType?e.target.parentNode:e.target,this.currentTarget=e.currentTarget,this.relatedTarget=e.relatedTarget):this.type=e,t&&S.extend(this,t),this.timeStamp=e&&e.timeStamp||Date.now(),this[S.expando]=!0},S.Event.prototype={constructor:S.Event,isDefaultPrevented:Ee,isPropagationStopped:Ee,isImmediatePropagationStopped:Ee,isSimulated:!1,preventDefault:function(){var e=this.originalEvent;this.isDefaultPrevented=Ce,e&&!this.isSimulated&&e.preventDefault()},stopPropagation:function(){var e=this.originalEvent;this.isPropagationStopped=Ce,e&&!this.isSimulated&&e.stopPropagation()},stopImmediatePropagation:function(){var e=this.originalEvent;this.isImmediatePropagationStopped=Ce,e&&!this.isSimulated&&e.stopImmediatePropagation(),this.stopPropagation()}},S.each({altKey:!0,bubbles:!0,cancelable:!0,changedTouches:!0,ctrlKey:!0,detail:!0,eventPhase:!0,metaKey:!0,pageX:!0,pageY:!0,shiftKey:!0,view:!0,"char":!0,code:!0,charCode:!0,key:!0,keyCode:!0,button:!0,buttons:!0,clientX:!0,clientY:!0,offsetX:!0,offsetY:!0,pointerId:!0,pointerType:!0,screenX:!0,screenY:!0,targetTouches:!0,toElement:!0,touches:!0,which:function(e){var t=e.button;return null==e.which&&be.test(e.type)?null!=e.charCode?e.charCode:e.keyCode:!e.which&&void 0!==t&&we.test(e.type)?1&t?1:2&t?3:4&t?2:0:e.which}},S.event.addProp),S.each({focus:"focusin",blur:"focusout"},function(e,t){S.event.special[e]={setup:function(){return Ae(this,e,Se),!1},trigger:function(){return Ae(this,e),!0},delegateType:t}}),S.each({mouseenter:"mouseover",mouseleave:"mouseout",pointerenter:"pointerover",pointerleave:"pointerout"},function(e,i){S.event.special[e]={delegateType:i,bindType:i,handle:function(e){var t,n=e.relatedTarget,r=e.handleObj;return n&&(n===this||S.contains(this,n))||(e.type=r.origType,t=r.handler.apply(this,arguments),e.type=i),t}}}),S.fn.extend({on:function(e,t,n,r){return ke(this,e,t,n,r)},one:function(e,t,n,r){return ke(this,e,t,n,r,1)},off:function(e,t,n){var r,i;if(e&&e.preventDefault&&e.handleObj)return r=e.handleObj,S(e.delegateTarget).off(r.namespace?r.origType+"."+r.namespace:r.origType,r.selector,r.handler),this;if("object"==typeof e){for(i in e)this.off(i,t,e[i]);return this}return!1!==t&&"function"!=typeof t||(n=t,t=void 0),!1===n&&(n=Ee),this.each(function(){S.event.remove(this,e,n,t)})}});var Ne=/<script|<style|<link/i,De=/checked\s*(?:[^=]|=\s*.checked.)/i,je=/^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;function qe(e,t){return A(e,"table")&&A(11!==t.nodeType?t:t.firstChild,"tr")&&S(e).children("tbody")[0]||e}function Le(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function He(e){return"true/"===(e.type||"").slice(0,5)?e.type=e.type.slice(5):e.removeAttribute("type"),e}function Oe(e,t){var n,r,i,o,a,s;if(1===t.nodeType){if(Y.hasData(e)&&(s=Y.get(e).events))for(i in Y.remove(t,"handle events"),s)for(n=0,r=s[i].length;n<r;n++)S.event.add(t,i,s[i][n]);Q.hasData(e)&&(o=Q.access(e),a=S.extend({},o),Q.set(t,a))}}function Pe(n,r,i,o){r=g(r);var e,t,a,s,u,l,c=0,f=n.length,p=f-1,d=r[0],h=m(d);if(h||1<f&&"string"==typeof d&&!y.checkClone&&De.test(d))return n.each(function(e){var t=n.eq(e);h&&(r[0]=d.call(this,e,t.html())),Pe(t,r,i,o)});if(f&&(t=(e=xe(r,n[0].ownerDocument,!1,n,o)).firstChild,1===e.childNodes.length&&(e=t),t||o)){for(s=(a=S.map(ve(e,"script"),Le)).length;c<f;c++)u=e,c!==p&&(u=S.clone(u,!0,!0),s&&S.merge(a,ve(u,"script"))),i.call(n[c],u,c);if(s)for(l=a[a.length-1].ownerDocument,S.map(a,He),c=0;c<s;c++)u=a[c],he.test(u.type||"")&&!Y.access(u,"globalEval")&&S.contains(l,u)&&(u.src&&"module"!==(u.type||"").toLowerCase()?S._evalUrl&&!u.noModule&&S._evalUrl(u.src,{nonce:u.nonce||u.getAttribute("nonce")},l):b(u.textContent.replace(je,""),u,l))}return n}function Re(e,t,n){for(var r,i=t?S.filter(t,e):e,o=0;null!=(r=i[o]);o++)n||1!==r.nodeType||S.cleanData(ve(r)),r.parentNode&&(n&&ie(r)&&ye(ve(r,"script")),r.parentNode.removeChild(r));return e}S.extend({htmlPrefilter:function(e){return e},clone:function(e,t,n){var r,i,o,a,s,u,l,c=e.cloneNode(!0),f=ie(e);if(!(y.noCloneChecked||1!==e.nodeType&&11!==e.nodeType||S.isXMLDoc(e)))for(a=ve(c),r=0,i=(o=ve(e)).length;r<i;r++)s=o[r],u=a[r],void 0,"input"===(l=u.nodeName.toLowerCase())&&pe.test(s.type)?u.checked=s.checked:"input"!==l&&"textarea"!==l||(u.defaultValue=s.defaultValue);if(t)if(n)for(o=o||ve(e),a=a||ve(c),r=0,i=o.length;r<i;r++)Oe(o[r],a[r]);else Oe(e,c);return 0<(a=ve(c,"script")).length&&ye(a,!f&&ve(e,"script")),c},cleanData:function(e){for(var t,n,r,i=S.event.special,o=0;void 0!==(n=e[o]);o++)if(V(n)){if(t=n[Y.expando]){if(t.events)for(r in t.events)i[r]?S.event.remove(n,r):S.removeEvent(n,r,t.handle);n[Y.expando]=void 0}n[Q.expando]&&(n[Q.expando]=void 0)}}}),S.fn.extend({detach:function(e){return Re(this,e,!0)},remove:function(e){return Re(this,e)},text:function(e){return $(this,function(e){return void 0===e?S.text(this):this.empty().each(function(){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||(this.textContent=e)})},null,e,arguments.length)},append:function(){return Pe(this,arguments,function(e){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||qe(this,e).appendChild(e)})},prepend:function(){return Pe(this,arguments,function(e){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var t=qe(this,e);t.insertBefore(e,t.firstChild)}})},before:function(){return Pe(this,arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this)})},after:function(){return Pe(this,arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this.nextSibling)})},empty:function(){for(var e,t=0;null!=(e=this[t]);t++)1===e.nodeType&&(S.cleanData(ve(e,!1)),e.textContent="");return this},clone:function(e,t){return e=null!=e&&e,t=null==t?e:t,this.map(function(){return S.clone(this,e,t)})},html:function(e){return $(this,function(e){var t=this[0]||{},n=0,r=this.length;if(void 0===e&&1===t.nodeType)return t.innerHTML;if("string"==typeof e&&!Ne.test(e)&&!ge[(de.exec(e)||["",""])[1].toLowerCase()]){e=S.htmlPrefilter(e);try{for(;n<r;n++)1===(t=this[n]||{}).nodeType&&(S.cleanData(ve(t,!1)),t.innerHTML=e);t=0}catch(e){}}t&&this.empty().append(e)},null,e,arguments.length)},replaceWith:function(){var n=[];return Pe(this,arguments,function(e){var t=this.parentNode;S.inArray(this,n)<0&&(S.cleanData(ve(this)),t&&t.replaceChild(e,this))},n)}}),S.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(e,a){S.fn[e]=function(e){for(var t,n=[],r=S(e),i=r.length-1,o=0;o<=i;o++)t=o===i?this:this.clone(!0),S(r[o])[a](t),u.apply(n,t.get());return this.pushStack(n)}});var Me=new RegExp("^("+ee+")(?!px)[a-z%]+$","i"),Ie=function(e){var t=e.ownerDocument.defaultView;return t&&t.opener||(t=C),t.getComputedStyle(e)},We=function(e,t,n){var r,i,o={};for(i in t)o[i]=e.style[i],e.style[i]=t[i];for(i in r=n.call(e),t)e.style[i]=o[i];return r},Fe=new RegExp(ne.join("|"),"i");function Be(e,t,n){var r,i,o,a,s=e.style;return(n=n||Ie(e))&&(""!==(a=n.getPropertyValue(t)||n[t])||ie(e)||(a=S.style(e,t)),!y.pixelBoxStyles()&&Me.test(a)&&Fe.test(t)&&(r=s.width,i=s.minWidth,o=s.maxWidth,s.minWidth=s.maxWidth=s.width=a,a=n.width,s.width=r,s.minWidth=i,s.maxWidth=o)),void 0!==a?a+"":a}function $e(e,t){return{get:function(){if(!e())return(this.get=t).apply(this,arguments);delete this.get}}}!function(){function e(){if(l){u.style.cssText="position:absolute;left:-11111px;width:60px;margin-top:1px;padding:0;border:0",l.style.cssText="position:relative;display:block;box-sizing:border-box;overflow:scroll;margin:auto;border:1px;padding:1px;width:60%;top:1%",re.appendChild(u).appendChild(l);var e=C.getComputedStyle(l);n="1%"!==e.top,s=12===t(e.marginLeft),l.style.right="60%",o=36===t(e.right),r=36===t(e.width),l.style.position="absolute",i=12===t(l.offsetWidth/3),re.removeChild(u),l=null}}function t(e){return Math.round(parseFloat(e))}var n,r,i,o,a,s,u=E.createElement("div"),l=E.createElement("div");l.style&&(l.style.backgroundClip="content-box",l.cloneNode(!0).style.backgroundClip="",y.clearCloneStyle="content-box"===l.style.backgroundClip,S.extend(y,{boxSizingReliable:function(){return e(),r},pixelBoxStyles:function(){return e(),o},pixelPosition:function(){return e(),n},reliableMarginLeft:function(){return e(),s},scrollboxSize:function(){return e(),i},reliableTrDimensions:function(){var e,t,n,r;return null==a&&(e=E.createElement("table"),t=E.createElement("tr"),n=E.createElement("div"),e.style.cssText="position:absolute;left:-11111px",t.style.height="1px",n.style.height="9px",re.appendChild(e).appendChild(t).appendChild(n),r=C.getComputedStyle(t),a=3<parseInt(r.height),re.removeChild(e)),a}}))}();var _e=["Webkit","Moz","ms"],ze=E.createElement("div").style,Ue={};function Xe(e){var t=S.cssProps[e]||Ue[e];return t||(e in ze?e:Ue[e]=function(e){var t=e[0].toUpperCase()+e.slice(1),n=_e.length;while(n--)if((e=_e[n]+t)in ze)return e}(e)||e)}var Ve=/^(none|table(?!-c[ea]).+)/,Ge=/^--/,Ye={position:"absolute",visibility:"hidden",display:"block"},Qe={letterSpacing:"0",fontWeight:"400"};function Je(e,t,n){var r=te.exec(t);return r?Math.max(0,r[2]-(n||0))+(r[3]||"px"):t}function Ke(e,t,n,r,i,o){var a="width"===t?1:0,s=0,u=0;if(n===(r?"border":"content"))return 0;for(;a<4;a+=2)"margin"===n&&(u+=S.css(e,n+ne[a],!0,i)),r?("content"===n&&(u-=S.css(e,"padding"+ne[a],!0,i)),"margin"!==n&&(u-=S.css(e,"border"+ne[a]+"Width",!0,i))):(u+=S.css(e,"padding"+ne[a],!0,i),"padding"!==n?u+=S.css(e,"border"+ne[a]+"Width",!0,i):s+=S.css(e,"border"+ne[a]+"Width",!0,i));return!r&&0<=o&&(u+=Math.max(0,Math.ceil(e["offset"+t[0].toUpperCase()+t.slice(1)]-o-u-s-.5))||0),u}function Ze(e,t,n){var r=Ie(e),i=(!y.boxSizingReliable()||n)&&"border-box"===S.css(e,"boxSizing",!1,r),o=i,a=Be(e,t,r),s="offset"+t[0].toUpperCase()+t.slice(1);if(Me.test(a)){if(!n)return a;a="auto"}return(!y.boxSizingReliable()&&i||!y.reliableTrDimensions()&&A(e,"tr")||"auto"===a||!parseFloat(a)&&"inline"===S.css(e,"display",!1,r))&&e.getClientRects().length&&(i="border-box"===S.css(e,"boxSizing",!1,r),(o=s in e)&&(a=e[s])),(a=parseFloat(a)||0)+Ke(e,t,n||(i?"border":"content"),o,r,a)+"px"}function et(e,t,n,r,i){return new et.prototype.init(e,t,n,r,i)}S.extend({cssHooks:{opacity:{get:function(e,t){if(t){var n=Be(e,"opacity");return""===n?"1":n}}}},cssNumber:{animationIterationCount:!0,columnCount:!0,fillOpacity:!0,flexGrow:!0,flexShrink:!0,fontWeight:!0,gridArea:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnStart:!0,gridRow:!0,gridRowEnd:!0,gridRowStart:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{},style:function(e,t,n,r){if(e&&3!==e.nodeType&&8!==e.nodeType&&e.style){var i,o,a,s=X(t),u=Ge.test(t),l=e.style;if(u||(t=Xe(s)),a=S.cssHooks[t]||S.cssHooks[s],void 0===n)return a&&"get"in a&&void 0!==(i=a.get(e,!1,r))?i:l[t];"string"===(o=typeof n)&&(i=te.exec(n))&&i[1]&&(n=se(e,t,i),o="number"),null!=n&&n==n&&("number"!==o||u||(n+=i&&i[3]||(S.cssNumber[s]?"":"px")),y.clearCloneStyle||""!==n||0!==t.indexOf("background")||(l[t]="inherit"),a&&"set"in a&&void 0===(n=a.set(e,n,r))||(u?l.setProperty(t,n):l[t]=n))}},css:function(e,t,n,r){var i,o,a,s=X(t);return Ge.test(t)||(t=Xe(s)),(a=S.cssHooks[t]||S.cssHooks[s])&&"get"in a&&(i=a.get(e,!0,n)),void 0===i&&(i=Be(e,t,r)),"normal"===i&&t in Qe&&(i=Qe[t]),""===n||n?(o=parseFloat(i),!0===n||isFinite(o)?o||0:i):i}}),S.each(["height","width"],function(e,u){S.cssHooks[u]={get:function(e,t,n){if(t)return!Ve.test(S.css(e,"display"))||e.getClientRects().length&&e.getBoundingClientRect().width?Ze(e,u,n):We(e,Ye,function(){return Ze(e,u,n)})},set:function(e,t,n){var r,i=Ie(e),o=!y.scrollboxSize()&&"absolute"===i.position,a=(o||n)&&"border-box"===S.css(e,"boxSizing",!1,i),s=n?Ke(e,u,n,a,i):0;return a&&o&&(s-=Math.ceil(e["offset"+u[0].toUpperCase()+u.slice(1)]-parseFloat(i[u])-Ke(e,u,"border",!1,i)-.5)),s&&(r=te.exec(t))&&"px"!==(r[3]||"px")&&(e.style[u]=t,t=S.css(e,u)),Je(0,t,s)}}}),S.cssHooks.marginLeft=$e(y.reliableMarginLeft,function(e,t){if(t)return(parseFloat(Be(e,"marginLeft"))||e.getBoundingClientRect().left-We(e,{marginLeft:0},function(){return e.getBoundingClientRect().left}))+"px"}),S.each({margin:"",padding:"",border:"Width"},function(i,o){S.cssHooks[i+o]={expand:function(e){for(var t=0,n={},r="string"==typeof e?e.split(" "):[e];t<4;t++)n[i+ne[t]+o]=r[t]||r[t-2]||r[0];return n}},"margin"!==i&&(S.cssHooks[i+o].set=Je)}),S.fn.extend({css:function(e,t){return $(this,function(e,t,n){var r,i,o={},a=0;if(Array.isArray(t)){for(r=Ie(e),i=t.length;a<i;a++)o[t[a]]=S.css(e,t[a],!1,r);return o}return void 0!==n?S.style(e,t,n):S.css(e,t)},e,t,1<arguments.length)}}),((S.Tween=et).prototype={constructor:et,init:function(e,t,n,r,i,o){this.elem=e,this.prop=n,this.easing=i||S.easing._default,this.options=t,this.start=this.now=this.cur(),this.end=r,this.unit=o||(S.cssNumber[n]?"":"px")},cur:function(){var e=et.propHooks[this.prop];return e&&e.get?e.get(this):et.propHooks._default.get(this)},run:function(e){var t,n=et.propHooks[this.prop];return this.options.duration?this.pos=t=S.easing[this.easing](e,this.options.duration*e,0,1,this.options.duration):this.pos=t=e,this.now=(this.end-this.start)*t+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),n&&n.set?n.set(this):et.propHooks._default.set(this),this}}).init.prototype=et.prototype,(et.propHooks={_default:{get:function(e){var t;return 1!==e.elem.nodeType||null!=e.elem[e.prop]&&null==e.elem.style[e.prop]?e.elem[e.prop]:(t=S.css(e.elem,e.prop,""))&&"auto"!==t?t:0},set:function(e){S.fx.step[e.prop]?S.fx.step[e.prop](e):1!==e.elem.nodeType||!S.cssHooks[e.prop]&&null==e.elem.style[Xe(e.prop)]?e.elem[e.prop]=e.now:S.style(e.elem,e.prop,e.now+e.unit)}}}).scrollTop=et.propHooks.scrollLeft={set:function(e){e.elem.nodeType&&e.elem.parentNode&&(e.elem[e.prop]=e.now)}},S.easing={linear:function(e){return e},swing:function(e){return.5-Math.cos(e*Math.PI)/2},_default:"swing"},S.fx=et.prototype.init,S.fx.step={};var tt,nt,rt,it,ot=/^(?:toggle|show|hide)$/,at=/queueHooks$/;function st(){nt&&(!1===E.hidden&&C.requestAnimationFrame?C.requestAnimationFrame(st):C.setTimeout(st,S.fx.interval),S.fx.tick())}function ut(){return C.setTimeout(function(){tt=void 0}),tt=Date.now()}function lt(e,t){var n,r=0,i={height:e};for(t=t?1:0;r<4;r+=2-t)i["margin"+(n=ne[r])]=i["padding"+n]=e;return t&&(i.opacity=i.width=e),i}function ct(e,t,n){for(var r,i=(ft.tweeners[t]||[]).concat(ft.tweeners["*"]),o=0,a=i.length;o<a;o++)if(r=i[o].call(n,t,e))return r}function ft(o,e,t){var n,a,r=0,i=ft.prefilters.length,s=S.Deferred().always(function(){delete u.elem}),u=function(){if(a)return!1;for(var e=tt||ut(),t=Math.max(0,l.startTime+l.duration-e),n=1-(t/l.duration||0),r=0,i=l.tweens.length;r<i;r++)l.tweens[r].run(n);return s.notifyWith(o,[l,n,t]),n<1&&i?t:(i||s.notifyWith(o,[l,1,0]),s.resolveWith(o,[l]),!1)},l=s.promise({elem:o,props:S.extend({},e),opts:S.extend(!0,{specialEasing:{},easing:S.easing._default},t),originalProperties:e,originalOptions:t,startTime:tt||ut(),duration:t.duration,tweens:[],createTween:function(e,t){var n=S.Tween(o,l.opts,e,t,l.opts.specialEasing[e]||l.opts.easing);return l.tweens.push(n),n},stop:function(e){var t=0,n=e?l.tweens.length:0;if(a)return this;for(a=!0;t<n;t++)l.tweens[t].run(1);return e?(s.notifyWith(o,[l,1,0]),s.resolveWith(o,[l,e])):s.rejectWith(o,[l,e]),this}}),c=l.props;for(!function(e,t){var n,r,i,o,a;for(n in e)if(i=t[r=X(n)],o=e[n],Array.isArray(o)&&(i=o[1],o=e[n]=o[0]),n!==r&&(e[r]=o,delete e[n]),(a=S.cssHooks[r])&&"expand"in a)for(n in o=a.expand(o),delete e[r],o)n in e||(e[n]=o[n],t[n]=i);else t[r]=i}(c,l.opts.specialEasing);r<i;r++)if(n=ft.prefilters[r].call(l,o,c,l.opts))return m(n.stop)&&(S._queueHooks(l.elem,l.opts.queue).stop=n.stop.bind(n)),n;return S.map(c,ct,l),m(l.opts.start)&&l.opts.start.call(o,l),l.progress(l.opts.progress).done(l.opts.done,l.opts.complete).fail(l.opts.fail).always(l.opts.always),S.fx.timer(S.extend(u,{elem:o,anim:l,queue:l.opts.queue})),l}S.Animation=S.extend(ft,{tweeners:{"*":[function(e,t){var n=this.createTween(e,t);return se(n.elem,e,te.exec(t),n),n}]},tweener:function(e,t){m(e)?(t=e,e=["*"]):e=e.match(P);for(var n,r=0,i=e.length;r<i;r++)n=e[r],ft.tweeners[n]=ft.tweeners[n]||[],ft.tweeners[n].unshift(t)},prefilters:[function(e,t,n){var r,i,o,a,s,u,l,c,f="width"in t||"height"in t,p=this,d={},h=e.style,g=e.nodeType&&ae(e),v=Y.get(e,"fxshow");for(r in n.queue||(null==(a=S._queueHooks(e,"fx")).unqueued&&(a.unqueued=0,s=a.empty.fire,a.empty.fire=function(){a.unqueued||s()}),a.unqueued++,p.always(function(){p.always(function(){a.unqueued--,S.queue(e,"fx").length||a.empty.fire()})})),t)if(i=t[r],ot.test(i)){if(delete t[r],o=o||"toggle"===i,i===(g?"hide":"show")){if("show"!==i||!v||void 0===v[r])continue;g=!0}d[r]=v&&v[r]||S.style(e,r)}if((u=!S.isEmptyObject(t))||!S.isEmptyObject(d))for(r in f&&1===e.nodeType&&(n.overflow=[h.overflow,h.overflowX,h.overflowY],null==(l=v&&v.display)&&(l=Y.get(e,"display")),"none"===(c=S.css(e,"display"))&&(l?c=l:(le([e],!0),l=e.style.display||l,c=S.css(e,"display"),le([e]))),("inline"===c||"inline-block"===c&&null!=l)&&"none"===S.css(e,"float")&&(u||(p.done(function(){h.display=l}),null==l&&(c=h.display,l="none"===c?"":c)),h.display="inline-block")),n.overflow&&(h.overflow="hidden",p.always(function(){h.overflow=n.overflow[0],h.overflowX=n.overflow[1],h.overflowY=n.overflow[2]})),u=!1,d)u||(v?"hidden"in v&&(g=v.hidden):v=Y.access(e,"fxshow",{display:l}),o&&(v.hidden=!g),g&&le([e],!0),p.done(function(){for(r in g||le([e]),Y.remove(e,"fxshow"),d)S.style(e,r,d[r])})),u=ct(g?v[r]:0,r,p),r in v||(v[r]=u.start,g&&(u.end=u.start,u.start=0))}],prefilter:function(e,t){t?ft.prefilters.unshift(e):ft.prefilters.push(e)}}),S.speed=function(e,t,n){var r=e&&"object"==typeof e?S.extend({},e):{complete:n||!n&&t||m(e)&&e,duration:e,easing:n&&t||t&&!m(t)&&t};return S.fx.off?r.duration=0:"number"!=typeof r.duration&&(r.duration in S.fx.speeds?r.duration=S.fx.speeds[r.duration]:r.duration=S.fx.speeds._default),null!=r.queue&&!0!==r.queue||(r.queue="fx"),r.old=r.complete,r.complete=function(){m(r.old)&&r.old.call(this),r.queue&&S.dequeue(this,r.queue)},r},S.fn.extend({fadeTo:function(e,t,n,r){return this.filter(ae).css("opacity",0).show().end().animate({opacity:t},e,n,r)},animate:function(t,e,n,r){var i=S.isEmptyObject(t),o=S.speed(e,n,r),a=function(){var e=ft(this,S.extend({},t),o);(i||Y.get(this,"finish"))&&e.stop(!0)};return a.finish=a,i||!1===o.queue?this.each(a):this.queue(o.queue,a)},stop:function(i,e,o){var a=function(e){var t=e.stop;delete e.stop,t(o)};return"string"!=typeof i&&(o=e,e=i,i=void 0),e&&this.queue(i||"fx",[]),this.each(function(){var e=!0,t=null!=i&&i+"queueHooks",n=S.timers,r=Y.get(this);if(t)r[t]&&r[t].stop&&a(r[t]);else for(t in r)r[t]&&r[t].stop&&at.test(t)&&a(r[t]);for(t=n.length;t--;)n[t].elem!==this||null!=i&&n[t].queue!==i||(n[t].anim.stop(o),e=!1,n.splice(t,1));!e&&o||S.dequeue(this,i)})},finish:function(a){return!1!==a&&(a=a||"fx"),this.each(function(){var e,t=Y.get(this),n=t[a+"queue"],r=t[a+"queueHooks"],i=S.timers,o=n?n.length:0;for(t.finish=!0,S.queue(this,a,[]),r&&r.stop&&r.stop.call(this,!0),e=i.length;e--;)i[e].elem===this&&i[e].queue===a&&(i[e].anim.stop(!0),i.splice(e,1));for(e=0;e<o;e++)n[e]&&n[e].finish&&n[e].finish.call(this);delete t.finish})}}),S.each(["toggle","show","hide"],function(e,r){var i=S.fn[r];S.fn[r]=function(e,t,n){return null==e||"boolean"==typeof e?i.apply(this,arguments):this.animate(lt(r,!0),e,t,n)}}),S.each({slideDown:lt("show"),slideUp:lt("hide"),slideToggle:lt("toggle"),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},function(e,r){S.fn[e]=function(e,t,n){return this.animate(r,e,t,n)}}),S.timers=[],S.fx.tick=function(){var e,t=0,n=S.timers;for(tt=Date.now();t<n.length;t++)(e=n[t])()||n[t]!==e||n.splice(t--,1);n.length||S.fx.stop(),tt=void 0},S.fx.timer=function(e){S.timers.push(e),S.fx.start()},S.fx.interval=13,S.fx.start=function(){nt||(nt=!0,st())},S.fx.stop=function(){nt=null},S.fx.speeds={slow:600,fast:200,_default:400},S.fn.delay=function(r,e){return r=S.fx&&S.fx.speeds[r]||r,e=e||"fx",this.queue(e,function(e,t){var n=C.setTimeout(e,r);t.stop=function(){C.clearTimeout(n)}})},rt=E.createElement("input"),it=E.createElement("select").appendChild(E.createElement("option")),rt.type="checkbox",y.checkOn=""!==rt.value,y.optSelected=it.selected,(rt=E.createElement("input")).value="t",rt.type="radio",y.radioValue="t"===rt.value;var pt,dt=S.expr.attrHandle;S.fn.extend({attr:function(e,t){return $(this,S.attr,e,t,1<arguments.length)},removeAttr:function(e){return this.each(function(){S.removeAttr(this,e)})}}),S.extend({attr:function(e,t,n){var r,i,o=e.nodeType;if(3!==o&&8!==o&&2!==o)return"undefined"==typeof e.getAttribute?S.prop(e,t,n):(1===o&&S.isXMLDoc(e)||(i=S.attrHooks[t.toLowerCase()]||(S.expr.match.bool.test(t)?pt:void 0)),void 0!==n?null===n?void S.removeAttr(e,t):i&&"set"in i&&void 0!==(r=i.set(e,n,t))?r:(e.setAttribute(t,n+""),n):i&&"get"in i&&null!==(r=i.get(e,t))?r:null==(r=S.find.attr(e,t))?void 0:r)},attrHooks:{type:{set:function(e,t){if(!y.radioValue&&"radio"===t&&A(e,"input")){var n=e.value;return e.setAttribute("type",t),n&&(e.value=n),t}}}},removeAttr:function(e,t){var n,r=0,i=t&&t.match(P);if(i&&1===e.nodeType)while(n=i[r++])e.removeAttribute(n)}}),pt={set:function(e,t,n){return!1===t?S.removeAttr(e,n):e.setAttribute(n,n),n}},S.each(S.expr.match.bool.source.match(/\w+/g),function(e,t){var a=dt[t]||S.find.attr;dt[t]=function(e,t,n){var r,i,o=t.toLowerCase();return n||(i=dt[o],dt[o]=r,r=null!=a(e,t,n)?o:null,dt[o]=i),r}});var ht=/^(?:input|select|textarea|button)$/i,gt=/^(?:a|area)$/i;function vt(e){return(e.match(P)||[]).join(" ")}function yt(e){return e.getAttribute&&e.getAttribute("class")||""}function mt(e){return Array.isArray(e)?e:"string"==typeof e&&e.match(P)||[]}S.fn.extend({prop:function(e,t){return $(this,S.prop,e,t,1<arguments.length)},removeProp:function(e){return this.each(function(){delete this[S.propFix[e]||e]})}}),S.extend({prop:function(e,t,n){var r,i,o=e.nodeType;if(3!==o&&8!==o&&2!==o)return 1===o&&S.isXMLDoc(e)||(t=S.propFix[t]||t,i=S.propHooks[t]),void 0!==n?i&&"set"in i&&void 0!==(r=i.set(e,n,t))?r:e[t]=n:i&&"get"in i&&null!==(r=i.get(e,t))?r:e[t]},propHooks:{tabIndex:{get:function(e){var t=S.find.attr(e,"tabindex");return t?parseInt(t,10):ht.test(e.nodeName)||gt.test(e.nodeName)&&e.href?0:-1}}},propFix:{"for":"htmlFor","class":"className"}}),y.optSelected||(S.propHooks.selected={get:function(e){var t=e.parentNode;return t&&t.parentNode&&t.parentNode.selectedIndex,null},set:function(e){var t=e.parentNode;t&&(t.selectedIndex,t.parentNode&&t.parentNode.selectedIndex)}}),S.each(["tabIndex","readOnly","maxLength","cellSpacing","cellPadding","rowSpan","colSpan","useMap","frameBorder","contentEditable"],function(){S.propFix[this.toLowerCase()]=this}),S.fn.extend({addClass:function(t){var e,n,r,i,o,a,s,u=0;if(m(t))return this.each(function(e){S(this).addClass(t.call(this,e,yt(this)))});if((e=mt(t)).length)while(n=this[u++])if(i=yt(n),r=1===n.nodeType&&" "+vt(i)+" "){a=0;while(o=e[a++])r.indexOf(" "+o+" ")<0&&(r+=o+" ");i!==(s=vt(r))&&n.setAttribute("class",s)}return this},removeClass:function(t){var e,n,r,i,o,a,s,u=0;if(m(t))return this.each(function(e){S(this).removeClass(t.call(this,e,yt(this)))});if(!arguments.length)return this.attr("class","");if((e=mt(t)).length)while(n=this[u++])if(i=yt(n),r=1===n.nodeType&&" "+vt(i)+" "){a=0;while(o=e[a++])while(-1<r.indexOf(" "+o+" "))r=r.replace(" "+o+" "," ");i!==(s=vt(r))&&n.setAttribute("class",s)}return this},toggleClass:function(i,t){var o=typeof i,a="string"===o||Array.isArray(i);return"boolean"==typeof t&&a?t?this.addClass(i):this.removeClass(i):m(i)?this.each(function(e){S(this).toggleClass(i.call(this,e,yt(this),t),t)}):this.each(function(){var e,t,n,r;if(a){t=0,n=S(this),r=mt(i);while(e=r[t++])n.hasClass(e)?n.removeClass(e):n.addClass(e)}else void 0!==i&&"boolean"!==o||((e=yt(this))&&Y.set(this,"__className__",e),this.setAttribute&&this.setAttribute("class",e||!1===i?"":Y.get(this,"__className__")||""))})},hasClass:function(e){var t,n,r=0;t=" "+e+" ";while(n=this[r++])if(1===n.nodeType&&-1<(" "+vt(yt(n))+" ").indexOf(t))return!0;return!1}});var xt=/\r/g;S.fn.extend({val:function(n){var r,e,i,t=this[0];return arguments.length?(i=m(n),this.each(function(e){var t;1===this.nodeType&&(null==(t=i?n.call(this,e,S(this).val()):n)?t="":"number"==typeof t?t+="":Array.isArray(t)&&(t=S.map(t,function(e){return null==e?"":e+""})),(r=S.valHooks[this.type]||S.valHooks[this.nodeName.toLowerCase()])&&"set"in r&&void 0!==r.set(this,t,"value")||(this.value=t))})):t?(r=S.valHooks[t.type]||S.valHooks[t.nodeName.toLowerCase()])&&"get"in r&&void 0!==(e=r.get(t,"value"))?e:"string"==typeof(e=t.value)?e.replace(xt,""):null==e?"":e:void 0}}),S.extend({valHooks:{option:{get:function(e){var t=S.find.attr(e,"value");return null!=t?t:vt(S.text(e))}},select:{get:function(e){var t,n,r,i=e.options,o=e.selectedIndex,a="select-one"===e.type,s=a?null:[],u=a?o+1:i.length;for(r=o<0?u:a?o:0;r<u;r++)if(((n=i[r]).selected||r===o)&&!n.disabled&&(!n.parentNode.disabled||!A(n.parentNode,"optgroup"))){if(t=S(n).val(),a)return t;s.push(t)}return s},set:function(e,t){var n,r,i=e.options,o=S.makeArray(t),a=i.length;while(a--)((r=i[a]).selected=-1<S.inArray(S.valHooks.option.get(r),o))&&(n=!0);return n||(e.selectedIndex=-1),o}}}}),S.each(["radio","checkbox"],function(){S.valHooks[this]={set:function(e,t){if(Array.isArray(t))return e.checked=-1<S.inArray(S(e).val(),t)}},y.checkOn||(S.valHooks[this].get=function(e){return null===e.getAttribute("value")?"on":e.value})}),y.focusin="onfocusin"in C;var bt=/^(?:focusinfocus|focusoutblur)$/,wt=function(e){e.stopPropagation()};S.extend(S.event,{trigger:function(e,t,n,r){var i,o,a,s,u,l,c,f,p=[n||E],d=v.call(e,"type")?e.type:e,h=v.call(e,"namespace")?e.namespace.split("."):[];if(o=f=a=n=n||E,3!==n.nodeType&&8!==n.nodeType&&!bt.test(d+S.event.triggered)&&(-1<d.indexOf(".")&&(d=(h=d.split(".")).shift(),h.sort()),u=d.indexOf(":")<0&&"on"+d,(e=e[S.expando]?e:new S.Event(d,"object"==typeof e&&e)).isTrigger=r?2:3,e.namespace=h.join("."),e.rnamespace=e.namespace?new RegExp("(^|\\.)"+h.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,e.result=void 0,e.target||(e.target=n),t=null==t?[e]:S.makeArray(t,[e]),c=S.event.special[d]||{},r||!c.trigger||!1!==c.trigger.apply(n,t))){if(!r&&!c.noBubble&&!x(n)){for(s=c.delegateType||d,bt.test(s+d)||(o=o.parentNode);o;o=o.parentNode)p.push(o),a=o;a===(n.ownerDocument||E)&&p.push(a.defaultView||a.parentWindow||C)}i=0;while((o=p[i++])&&!e.isPropagationStopped())f=o,e.type=1<i?s:c.bindType||d,(l=(Y.get(o,"events")||Object.create(null))[e.type]&&Y.get(o,"handle"))&&l.apply(o,t),(l=u&&o[u])&&l.apply&&V(o)&&(e.result=l.apply(o,t),!1===e.result&&e.preventDefault());return e.type=d,r||e.isDefaultPrevented()||c._default&&!1!==c._default.apply(p.pop(),t)||!V(n)||u&&m(n[d])&&!x(n)&&((a=n[u])&&(n[u]=null),S.event.triggered=d,e.isPropagationStopped()&&f.addEventListener(d,wt),n[d](),e.isPropagationStopped()&&f.removeEventListener(d,wt),S.event.triggered=void 0,a&&(n[u]=a)),e.result}},simulate:function(e,t,n){var r=S.extend(new S.Event,n,{type:e,isSimulated:!0});S.event.trigger(r,null,t)}}),S.fn.extend({trigger:function(e,t){return this.each(function(){S.event.trigger(e,t,this)})},triggerHandler:function(e,t){var n=this[0];if(n)return S.event.trigger(e,t,n,!0)}}),y.focusin||S.each({focus:"focusin",blur:"focusout"},function(n,r){var i=function(e){S.event.simulate(r,e.target,S.event.fix(e))};S.event.special[r]={setup:function(){var e=this.ownerDocument||this.document||this,t=Y.access(e,r);t||e.addEventListener(n,i,!0),Y.access(e,r,(t||0)+1)},teardown:function(){var e=this.ownerDocument||this.document||this,t=Y.access(e,r)-1;t?Y.access(e,r,t):(e.removeEventListener(n,i,!0),Y.remove(e,r))}}});var Tt=C.location,Ct={guid:Date.now()},Et=/\?/;S.parseXML=function(e){var t;if(!e||"string"!=typeof e)return null;try{t=(new C.DOMParser).parseFromString(e,"text/xml")}catch(e){t=void 0}return t&&!t.getElementsByTagName("parsererror").length||S.error("Invalid XML: "+e),t};var St=/\[\]$/,kt=/\r?\n/g,At=/^(?:submit|button|image|reset|file)$/i,Nt=/^(?:input|select|textarea|keygen)/i;function Dt(n,e,r,i){var t;if(Array.isArray(e))S.each(e,function(e,t){r||St.test(n)?i(n,t):Dt(n+"["+("object"==typeof t&&null!=t?e:"")+"]",t,r,i)});else if(r||"object"!==w(e))i(n,e);else for(t in e)Dt(n+"["+t+"]",e[t],r,i)}S.param=function(e,t){var n,r=[],i=function(e,t){var n=m(t)?t():t;r[r.length]=encodeURIComponent(e)+"="+encodeURIComponent(null==n?"":n)};if(null==e)return"";if(Array.isArray(e)||e.jquery&&!S.isPlainObject(e))S.each(e,function(){i(this.name,this.value)});else for(n in e)Dt(n,e[n],t,i);return r.join("&")},S.fn.extend({serialize:function(){return S.param(this.serializeArray())},serializeArray:function(){return this.map(function(){var e=S.prop(this,"elements");return e?S.makeArray(e):this}).filter(function(){var e=this.type;return this.name&&!S(this).is(":disabled")&&Nt.test(this.nodeName)&&!At.test(e)&&(this.checked||!pe.test(e))}).map(function(e,t){var n=S(this).val();return null==n?null:Array.isArray(n)?S.map(n,function(e){return{name:t.name,value:e.replace(kt,"\r\n")}}):{name:t.name,value:n.replace(kt,"\r\n")}}).get()}});var jt=/%20/g,qt=/#.*$/,Lt=/([?&])_=[^&]*/,Ht=/^(.*?):[ \t]*([^\r\n]*)$/gm,Ot=/^(?:GET|HEAD)$/,Pt=/^\/\//,Rt={},Mt={},It="*/".concat("*"),Wt=E.createElement("a");function Ft(o){return function(e,t){"string"!=typeof e&&(t=e,e="*");var n,r=0,i=e.toLowerCase().match(P)||[];if(m(t))while(n=i[r++])"+"===n[0]?(n=n.slice(1)||"*",(o[n]=o[n]||[]).unshift(t)):(o[n]=o[n]||[]).push(t)}}function Bt(t,i,o,a){var s={},u=t===Mt;function l(e){var r;return s[e]=!0,S.each(t[e]||[],function(e,t){var n=t(i,o,a);return"string"!=typeof n||u||s[n]?u?!(r=n):void 0:(i.dataTypes.unshift(n),l(n),!1)}),r}return l(i.dataTypes[0])||!s["*"]&&l("*")}function $t(e,t){var n,r,i=S.ajaxSettings.flatOptions||{};for(n in t)void 0!==t[n]&&((i[n]?e:r||(r={}))[n]=t[n]);return r&&S.extend(!0,e,r),e}Wt.href=Tt.href,S.extend({active:0,lastModified:{},etag:{},ajaxSettings:{url:Tt.href,type:"GET",isLocal:/^(?:about|app|app-storage|.+-extension|file|res|widget):$/.test(Tt.protocol),global:!0,processData:!0,async:!0,contentType:"application/x-www-form-urlencoded; charset=UTF-8",accepts:{"*":It,text:"text/plain",html:"text/html",xml:"application/xml, text/xml",json:"application/json, text/javascript"},contents:{xml:/\bxml\b/,html:/\bhtml/,json:/\bjson\b/},responseFields:{xml:"responseXML",text:"responseText",json:"responseJSON"},converters:{"* text":String,"text html":!0,"text json":JSON.parse,"text xml":S.parseXML},flatOptions:{url:!0,context:!0}},ajaxSetup:function(e,t){return t?$t($t(e,S.ajaxSettings),t):$t(S.ajaxSettings,e)},ajaxPrefilter:Ft(Rt),ajaxTransport:Ft(Mt),ajax:function(e,t){"object"==typeof e&&(t=e,e=void 0),t=t||{};var c,f,p,n,d,r,h,g,i,o,v=S.ajaxSetup({},t),y=v.context||v,m=v.context&&(y.nodeType||y.jquery)?S(y):S.event,x=S.Deferred(),b=S.Callbacks("once memory"),w=v.statusCode||{},a={},s={},u="canceled",T={readyState:0,getResponseHeader:function(e){var t;if(h){if(!n){n={};while(t=Ht.exec(p))n[t[1].toLowerCase()+" "]=(n[t[1].toLowerCase()+" "]||[]).concat(t[2])}t=n[e.toLowerCase()+" "]}return null==t?null:t.join(", ")},getAllResponseHeaders:function(){return h?p:null},setRequestHeader:function(e,t){return null==h&&(e=s[e.toLowerCase()]=s[e.toLowerCase()]||e,a[e]=t),this},overrideMimeType:function(e){return null==h&&(v.mimeType=e),this},statusCode:function(e){var t;if(e)if(h)T.always(e[T.status]);else for(t in e)w[t]=[w[t],e[t]];return this},abort:function(e){var t=e||u;return c&&c.abort(t),l(0,t),this}};if(x.promise(T),v.url=((e||v.url||Tt.href)+"").replace(Pt,Tt.protocol+"//"),v.type=t.method||t.type||v.method||v.type,v.dataTypes=(v.dataType||"*").toLowerCase().match(P)||[""],null==v.crossDomain){r=E.createElement("a");try{r.href=v.url,r.href=r.href,v.crossDomain=Wt.protocol+"//"+Wt.host!=r.protocol+"//"+r.host}catch(e){v.crossDomain=!0}}if(v.data&&v.processData&&"string"!=typeof v.data&&(v.data=S.param(v.data,v.traditional)),Bt(Rt,v,t,T),h)return T;for(i in(g=S.event&&v.global)&&0==S.active++&&S.event.trigger("ajaxStart"),v.type=v.type.toUpperCase(),v.hasContent=!Ot.test(v.type),f=v.url.replace(qt,""),v.hasContent?v.data&&v.processData&&0===(v.contentType||"").indexOf("application/x-www-form-urlencoded")&&(v.data=v.data.replace(jt,"+")):(o=v.url.slice(f.length),v.data&&(v.processData||"string"==typeof v.data)&&(f+=(Et.test(f)?"&":"?")+v.data,delete v.data),!1===v.cache&&(f=f.replace(Lt,"$1"),o=(Et.test(f)?"&":"?")+"_="+Ct.guid+++o),v.url=f+o),v.ifModified&&(S.lastModified[f]&&T.setRequestHeader("If-Modified-Since",S.lastModified[f]),S.etag[f]&&T.setRequestHeader("If-None-Match",S.etag[f])),(v.data&&v.hasContent&&!1!==v.contentType||t.contentType)&&T.setRequestHeader("Content-Type",v.contentType),T.setRequestHeader("Accept",v.dataTypes[0]&&v.accepts[v.dataTypes[0]]?v.accepts[v.dataTypes[0]]+("*"!==v.dataTypes[0]?", "+It+"; q=0.01":""):v.accepts["*"]),v.headers)T.setRequestHeader(i,v.headers[i]);if(v.beforeSend&&(!1===v.beforeSend.call(y,T,v)||h))return T.abort();if(u="abort",b.add(v.complete),T.done(v.success),T.fail(v.error),c=Bt(Mt,v,t,T)){if(T.readyState=1,g&&m.trigger("ajaxSend",[T,v]),h)return T;v.async&&0<v.timeout&&(d=C.setTimeout(function(){T.abort("timeout")},v.timeout));try{h=!1,c.send(a,l)}catch(e){if(h)throw e;l(-1,e)}}else l(-1,"No Transport");function l(e,t,n,r){var i,o,a,s,u,l=t;h||(h=!0,d&&C.clearTimeout(d),c=void 0,p=r||"",T.readyState=0<e?4:0,i=200<=e&&e<300||304===e,n&&(s=function(e,t,n){var r,i,o,a,s=e.contents,u=e.dataTypes;while("*"===u[0])u.shift(),void 0===r&&(r=e.mimeType||t.getResponseHeader("Content-Type"));if(r)for(i in s)if(s[i]&&s[i].test(r)){u.unshift(i);break}if(u[0]in n)o=u[0];else{for(i in n){if(!u[0]||e.converters[i+" "+u[0]]){o=i;break}a||(a=i)}o=o||a}if(o)return o!==u[0]&&u.unshift(o),n[o]}(v,T,n)),!i&&-1<S.inArray("script",v.dataTypes)&&(v.converters["text script"]=function(){}),s=function(e,t,n,r){var i,o,a,s,u,l={},c=e.dataTypes.slice();if(c[1])for(a in e.converters)l[a.toLowerCase()]=e.converters[a];o=c.shift();while(o)if(e.responseFields[o]&&(n[e.responseFields[o]]=t),!u&&r&&e.dataFilter&&(t=e.dataFilter(t,e.dataType)),u=o,o=c.shift())if("*"===o)o=u;else if("*"!==u&&u!==o){if(!(a=l[u+" "+o]||l["* "+o]))for(i in l)if((s=i.split(" "))[1]===o&&(a=l[u+" "+s[0]]||l["* "+s[0]])){!0===a?a=l[i]:!0!==l[i]&&(o=s[0],c.unshift(s[1]));break}if(!0!==a)if(a&&e["throws"])t=a(t);else try{t=a(t)}catch(e){return{state:"parsererror",error:a?e:"No conversion from "+u+" to "+o}}}return{state:"success",data:t}}(v,s,T,i),i?(v.ifModified&&((u=T.getResponseHeader("Last-Modified"))&&(S.lastModified[f]=u),(u=T.getResponseHeader("etag"))&&(S.etag[f]=u)),204===e||"HEAD"===v.type?l="nocontent":304===e?l="notmodified":(l=s.state,o=s.data,i=!(a=s.error))):(a=l,!e&&l||(l="error",e<0&&(e=0))),T.status=e,T.statusText=(t||l)+"",i?x.resolveWith(y,[o,l,T]):x.rejectWith(y,[T,l,a]),T.statusCode(w),w=void 0,g&&m.trigger(i?"ajaxSuccess":"ajaxError",[T,v,i?o:a]),b.fireWith(y,[T,l]),g&&(m.trigger("ajaxComplete",[T,v]),--S.active||S.event.trigger("ajaxStop")))}return T},getJSON:function(e,t,n){return S.get(e,t,n,"json")},getScript:function(e,t){return S.get(e,void 0,t,"script")}}),S.each(["get","post"],function(e,i){S[i]=function(e,t,n,r){return m(t)&&(r=r||n,n=t,t=void 0),S.ajax(S.extend({url:e,type:i,dataType:r,data:t,success:n},S.isPlainObject(e)&&e))}}),S.ajaxPrefilter(function(e){var t;for(t in e.headers)"content-type"===t.toLowerCase()&&(e.contentType=e.headers[t]||"")}),S._evalUrl=function(e,t,n){return S.ajax({url:e,type:"GET",dataType:"script",cache:!0,async:!1,global:!1,converters:{"text script":function(){}},dataFilter:function(e){S.globalEval(e,t,n)}})},S.fn.extend({wrapAll:function(e){var t;return this[0]&&(m(e)&&(e=e.call(this[0])),t=S(e,this[0].ownerDocument).eq(0).clone(!0),this[0].parentNode&&t.insertBefore(this[0]),t.map(function(){var e=this;while(e.firstElementChild)e=e.firstElementChild;return e}).append(this)),this},wrapInner:function(n){return m(n)?this.each(function(e){S(this).wrapInner(n.call(this,e))}):this.each(function(){var e=S(this),t=e.contents();t.length?t.wrapAll(n):e.append(n)})},wrap:function(t){var n=m(t);return this.each(function(e){S(this).wrapAll(n?t.call(this,e):t)})},unwrap:function(e){return this.parent(e).not("body").each(function(){S(this).replaceWith(this.childNodes)}),this}}),S.expr.pseudos.hidden=function(e){return!S.expr.pseudos.visible(e)},S.expr.pseudos.visible=function(e){return!!(e.offsetWidth||e.offsetHeight||e.getClientRects().length)},S.ajaxSettings.xhr=function(){try{return new C.XMLHttpRequest}catch(e){}};var _t={0:200,1223:204},zt=S.ajaxSettings.xhr();y.cors=!!zt&&"withCredentials"in zt,y.ajax=zt=!!zt,S.ajaxTransport(function(i){var o,a;if(y.cors||zt&&!i.crossDomain)return{send:function(e,t){var n,r=i.xhr();if(r.open(i.type,i.url,i.async,i.username,i.password),i.xhrFields)for(n in i.xhrFields)r[n]=i.xhrFields[n];for(n in i.mimeType&&r.overrideMimeType&&r.overrideMimeType(i.mimeType),i.crossDomain||e["X-Requested-With"]||(e["X-Requested-With"]="XMLHttpRequest"),e)r.setRequestHeader(n,e[n]);o=function(e){return function(){o&&(o=a=r.onload=r.onerror=r.onabort=r.ontimeout=r.onreadystatechange=null,"abort"===e?r.abort():"error"===e?"number"!=typeof r.status?t(0,"error"):t(r.status,r.statusText):t(_t[r.status]||r.status,r.statusText,"text"!==(r.responseType||"text")||"string"!=typeof r.responseText?{binary:r.response}:{text:r.responseText},r.getAllResponseHeaders()))}},r.onload=o(),a=r.onerror=r.ontimeout=o("error"),void 0!==r.onabort?r.onabort=a:r.onreadystatechange=function(){4===r.readyState&&C.setTimeout(function(){o&&a()})},o=o("abort");try{r.send(i.hasContent&&i.data||null)}catch(e){if(o)throw e}},abort:function(){o&&o()}}}),S.ajaxPrefilter(function(e){e.crossDomain&&(e.contents.script=!1)}),S.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/\b(?:java|ecma)script\b/},converters:{"text script":function(e){return S.globalEval(e),e}}}),S.ajaxPrefilter("script",function(e){void 0===e.cache&&(e.cache=!1),e.crossDomain&&(e.type="GET")}),S.ajaxTransport("script",function(n){var r,i;if(n.crossDomain||n.scriptAttrs)return{send:function(e,t){r=S("<script>").attr(n.scriptAttrs||{}).prop({charset:n.scriptCharset,src:n.url}).on("load error",i=function(e){r.remove(),i=null,e&&t("error"===e.type?404:200,e.type)}),E.head.appendChild(r[0])},abort:function(){i&&i()}}});var Ut,Xt=[],Vt=/(=)\?(?=&|$)|\?\?/;S.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var e=Xt.pop()||S.expando+"_"+Ct.guid++;return this[e]=!0,e}}),S.ajaxPrefilter("json jsonp",function(e,t,n){var r,i,o,a=!1!==e.jsonp&&(Vt.test(e.url)?"url":"string"==typeof e.data&&0===(e.contentType||"").indexOf("application/x-www-form-urlencoded")&&Vt.test(e.data)&&"data");if(a||"jsonp"===e.dataTypes[0])return r=e.jsonpCallback=m(e.jsonpCallback)?e.jsonpCallback():e.jsonpCallback,a?e[a]=e[a].replace(Vt,"$1"+r):!1!==e.jsonp&&(e.url+=(Et.test(e.url)?"&":"?")+e.jsonp+"="+r),e.converters["script json"]=function(){return o||S.error(r+" was not called"),o[0]},e.dataTypes[0]="json",i=C[r],C[r]=function(){o=arguments},n.always(function(){void 0===i?S(C).removeProp(r):C[r]=i,e[r]&&(e.jsonpCallback=t.jsonpCallback,Xt.push(r)),o&&m(i)&&i(o[0]),o=i=void 0}),"script"}),y.createHTMLDocument=((Ut=E.implementation.createHTMLDocument("").body).innerHTML="<form></form><form></form>",2===Ut.childNodes.length),S.parseHTML=function(e,t,n){return"string"!=typeof e?[]:("boolean"==typeof t&&(n=t,t=!1),t||(y.createHTMLDocument?((r=(t=E.implementation.createHTMLDocument("")).createElement("base")).href=E.location.href,t.head.appendChild(r)):t=E),o=!n&&[],(i=N.exec(e))?[t.createElement(i[1])]:(i=xe([e],t,o),o&&o.length&&S(o).remove(),S.merge([],i.childNodes)));var r,i,o},S.fn.load=function(e,t,n){var r,i,o,a=this,s=e.indexOf(" ");return-1<s&&(r=vt(e.slice(s)),e=e.slice(0,s)),m(t)?(n=t,t=void 0):t&&"object"==typeof t&&(i="POST"),0<a.length&&S.ajax({url:e,type:i||"GET",dataType:"html",data:t}).done(function(e){o=arguments,a.html(r?S("<div>").append(S.parseHTML(e)).find(r):e)}).always(n&&function(e,t){a.each(function(){n.apply(this,o||[e.responseText,t,e])})}),this},S.expr.pseudos.animated=function(t){return S.grep(S.timers,function(e){return t===e.elem}).length},S.offset={setOffset:function(e,t,n){var r,i,o,a,s,u,l=S.css(e,"position"),c=S(e),f={};"static"===l&&(e.style.position="relative"),s=c.offset(),o=S.css(e,"top"),u=S.css(e,"left"),("absolute"===l||"fixed"===l)&&-1<(o+u).indexOf("auto")?(a=(r=c.position()).top,i=r.left):(a=parseFloat(o)||0,i=parseFloat(u)||0),m(t)&&(t=t.call(e,n,S.extend({},s))),null!=t.top&&(f.top=t.top-s.top+a),null!=t.left&&(f.left=t.left-s.left+i),"using"in t?t.using.call(e,f):("number"==typeof f.top&&(f.top+="px"),"number"==typeof f.left&&(f.left+="px"),c.css(f))}},S.fn.extend({offset:function(t){if(arguments.length)return void 0===t?this:this.each(function(e){S.offset.setOffset(this,t,e)});var e,n,r=this[0];return r?r.getClientRects().length?(e=r.getBoundingClientRect(),n=r.ownerDocument.defaultView,{top:e.top+n.pageYOffset,left:e.left+n.pageXOffset}):{top:0,left:0}:void 0},position:function(){if(this[0]){var e,t,n,r=this[0],i={top:0,left:0};if("fixed"===S.css(r,"position"))t=r.getBoundingClientRect();else{t=this.offset(),n=r.ownerDocument,e=r.offsetParent||n.documentElement;while(e&&(e===n.body||e===n.documentElement)&&"static"===S.css(e,"position"))e=e.parentNode;e&&e!==r&&1===e.nodeType&&((i=S(e).offset()).top+=S.css(e,"borderTopWidth",!0),i.left+=S.css(e,"borderLeftWidth",!0))}return{top:t.top-i.top-S.css(r,"marginTop",!0),left:t.left-i.left-S.css(r,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var e=this.offsetParent;while(e&&"static"===S.css(e,"position"))e=e.offsetParent;return e||re})}}),S.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(t,i){var o="pageYOffset"===i;S.fn[t]=function(e){return $(this,function(e,t,n){var r;if(x(e)?r=e:9===e.nodeType&&(r=e.defaultView),void 0===n)return r?r[i]:e[t];r?r.scrollTo(o?r.pageXOffset:n,o?n:r.pageYOffset):e[t]=n},t,e,arguments.length)}}),S.each(["top","left"],function(e,n){S.cssHooks[n]=$e(y.pixelPosition,function(e,t){if(t)return t=Be(e,n),Me.test(t)?S(e).position()[n]+"px":t})}),S.each({Height:"height",Width:"width"},function(a,s){S.each({padding:"inner"+a,content:s,"":"outer"+a},function(r,o){S.fn[o]=function(e,t){var n=arguments.length&&(r||"boolean"!=typeof e),i=r||(!0===e||!0===t?"margin":"border");return $(this,function(e,t,n){var r;return x(e)?0===o.indexOf("outer")?e["inner"+a]:e.document.documentElement["client"+a]:9===e.nodeType?(r=e.documentElement,Math.max(e.body["scroll"+a],r["scroll"+a],e.body["offset"+a],r["offset"+a],r["client"+a])):void 0===n?S.css(e,t,i):S.style(e,t,n,i)},s,n?e:void 0,n)}})}),S.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(e,t){S.fn[t]=function(e){return this.on(t,e)}}),S.fn.extend({bind:function(e,t,n){return this.on(e,null,t,n)},unbind:function(e,t){return this.off(e,null,t)},delegate:function(e,t,n,r){return this.on(t,e,n,r)},undelegate:function(e,t,n){return 1===arguments.length?this.off(e,"**"):this.off(t,e||"**",n)},hover:function(e,t){return this.mouseenter(e).mouseleave(t||e)}}),S.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),function(e,n){S.fn[n]=function(e,t){return 0<arguments.length?this.on(n,null,e,t):this.trigger(n)}});var Gt=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;S.proxy=function(e,t){var n,r,i;if("string"==typeof t&&(n=e[t],t=e,e=n),m(e))return r=s.call(arguments,2),(i=function(){return e.apply(t||this,r.concat(s.call(arguments)))}).guid=e.guid=e.guid||S.guid++,i},S.holdReady=function(e){e?S.readyWait++:S.ready(!0)},S.isArray=Array.isArray,S.parseJSON=JSON.parse,S.nodeName=A,S.isFunction=m,S.isWindow=x,S.camelCase=X,S.type=w,S.now=Date.now,S.isNumeric=function(e){var t=S.type(e);return("number"===t||"string"===t)&&!isNaN(e-parseFloat(e))},S.trim=function(e){return null==e?"":(e+"").replace(Gt,"")},"function"==typeof define&&define.amd&&define("jquery",[],function(){return S});var Yt=C.jQuery,Qt=C.$;return S.noConflict=function(e){return C.$===S&&(C.$=Qt),e&&C.jQuery===S&&(C.jQuery=Yt),S},"undefined"==typeof e&&(C.jQuery=C.$=S),S});
+/*! jQuery v3.6.0 | (c) OpenJS Foundation and other contributors | jquery.org/license */
+!function(e,t){"use strict";"object"==typeof module&&"object"==typeof module.exports?module.exports=e.document?t(e,!0):function(e){if(!e.document)throw new Error("jQuery requires a window with a document");return t(e)}:t(e)}("undefined"!=typeof window?window:this,function(C,e){"use strict";var t=[],r=Object.getPrototypeOf,s=t.slice,g=t.flat?function(e){return t.flat.call(e)}:function(e){return t.concat.apply([],e)},u=t.push,i=t.indexOf,n={},o=n.toString,v=n.hasOwnProperty,a=v.toString,l=a.call(Object),y={},m=function(e){return"function"==typeof e&&"number"!=typeof e.nodeType&&"function"!=typeof e.item},x=function(e){return null!=e&&e===e.window},E=C.document,c={type:!0,src:!0,nonce:!0,noModule:!0};function b(e,t,n){var r,i,o=(n=n||E).createElement("script");if(o.text=e,t)for(r in c)(i=t[r]||t.getAttribute&&t.getAttribute(r))&&o.setAttribute(r,i);n.head.appendChild(o).parentNode.removeChild(o)}function w(e){return null==e?e+"":"object"==typeof e||"function"==typeof e?n[o.call(e)]||"object":typeof e}var f="3.6.0",S=function(e,t){return new S.fn.init(e,t)};function p(e){var t=!!e&&"length"in e&&e.length,n=w(e);return!m(e)&&!x(e)&&("array"===n||0===t||"number"==typeof t&&0<t&&t-1 in e)}S.fn=S.prototype={jquery:f,constructor:S,length:0,toArray:function(){return s.call(this)},get:function(e){return null==e?s.call(this):e<0?this[e+this.length]:this[e]},pushStack:function(e){var t=S.merge(this.constructor(),e);return t.prevObject=this,t},each:function(e){return S.each(this,e)},map:function(n){return this.pushStack(S.map(this,function(e,t){return n.call(e,t,e)}))},slice:function(){return this.pushStack(s.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},even:function(){return this.pushStack(S.grep(this,function(e,t){return(t+1)%2}))},odd:function(){return this.pushStack(S.grep(this,function(e,t){return t%2}))},eq:function(e){var t=this.length,n=+e+(e<0?t:0);return this.pushStack(0<=n&&n<t?[this[n]]:[])},end:function(){return this.prevObject||this.constructor()},push:u,sort:t.sort,splice:t.splice},S.extend=S.fn.extend=function(){var e,t,n,r,i,o,a=arguments[0]||{},s=1,u=arguments.length,l=!1;for("boolean"==typeof a&&(l=a,a=arguments[s]||{},s++),"object"==typeof a||m(a)||(a={}),s===u&&(a=this,s--);s<u;s++)if(null!=(e=arguments[s]))for(t in e)r=e[t],"__proto__"!==t&&a!==r&&(l&&r&&(S.isPlainObject(r)||(i=Array.isArray(r)))?(n=a[t],o=i&&!Array.isArray(n)?[]:i||S.isPlainObject(n)?n:{},i=!1,a[t]=S.extend(l,o,r)):void 0!==r&&(a[t]=r));return a},S.extend({expando:"jQuery"+(f+Math.random()).replace(/\D/g,""),isReady:!0,error:function(e){throw new Error(e)},noop:function(){},isPlainObject:function(e){var t,n;return!(!e||"[object Object]"!==o.call(e))&&(!(t=r(e))||"function"==typeof(n=v.call(t,"constructor")&&t.constructor)&&a.call(n)===l)},isEmptyObject:function(e){var t;for(t in e)return!1;return!0},globalEval:function(e,t,n){b(e,{nonce:t&&t.nonce},n)},each:function(e,t){var n,r=0;if(p(e)){for(n=e.length;r<n;r++)if(!1===t.call(e[r],r,e[r]))break}else for(r in e)if(!1===t.call(e[r],r,e[r]))break;return e},makeArray:function(e,t){var n=t||[];return null!=e&&(p(Object(e))?S.merge(n,"string"==typeof e?[e]:e):u.call(n,e)),n},inArray:function(e,t,n){return null==t?-1:i.call(t,e,n)},merge:function(e,t){for(var n=+t.length,r=0,i=e.length;r<n;r++)e[i++]=t[r];return e.length=i,e},grep:function(e,t,n){for(var r=[],i=0,o=e.length,a=!n;i<o;i++)!t(e[i],i)!==a&&r.push(e[i]);return r},map:function(e,t,n){var r,i,o=0,a=[];if(p(e))for(r=e.length;o<r;o++)null!=(i=t(e[o],o,n))&&a.push(i);else for(o in e)null!=(i=t(e[o],o,n))&&a.push(i);return g(a)},guid:1,support:y}),"function"==typeof Symbol&&(S.fn[Symbol.iterator]=t[Symbol.iterator]),S.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "),function(e,t){n["[object "+t+"]"]=t.toLowerCase()});var d=function(n){var e,d,b,o,i,h,f,g,w,u,l,T,C,a,E,v,s,c,y,S="sizzle"+1*new Date,p=n.document,k=0,r=0,m=ue(),x=ue(),A=ue(),N=ue(),j=function(e,t){return e===t&&(l=!0),0},D={}.hasOwnProperty,t=[],q=t.pop,L=t.push,H=t.push,O=t.slice,P=function(e,t){for(var n=0,r=e.length;n<r;n++)if(e[n]===t)return n;return-1},R="checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",M="[\\x20\\t\\r\\n\\f]",I="(?:\\\\[\\da-fA-F]{1,6}"+M+"?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+",W="\\["+M+"*("+I+")(?:"+M+"*([*^$|!~]?=)"+M+"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|("+I+"))|)"+M+"*\\]",F=":("+I+")(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[\\]]|"+W+")*)|.*)\\)|)",B=new RegExp(M+"+","g"),$=new RegExp("^"+M+"+|((?:^|[^\\\\])(?:\\\\.)*)"+M+"+$","g"),_=new RegExp("^"+M+"*,"+M+"*"),z=new RegExp("^"+M+"*([>+~]|"+M+")"+M+"*"),U=new RegExp(M+"|>"),X=new RegExp(F),V=new RegExp("^"+I+"$"),G={ID:new RegExp("^#("+I+")"),CLASS:new RegExp("^\\.("+I+")"),TAG:new RegExp("^("+I+"|[*])"),ATTR:new RegExp("^"+W),PSEUDO:new RegExp("^"+F),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+M+"*(even|odd|(([+-]|)(\\d*)n|)"+M+"*(?:([+-]|)"+M+"*(\\d+)|))"+M+"*\\)|)","i"),bool:new RegExp("^(?:"+R+")$","i"),needsContext:new RegExp("^"+M+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+M+"*((?:-\\d)?\\d*)"+M+"*\\)|)(?=[^-]|$)","i")},Y=/HTML$/i,Q=/^(?:input|select|textarea|button)$/i,J=/^h\d$/i,K=/^[^{]+\{\s*\[native \w/,Z=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,ee=/[+~]/,te=new RegExp("\\\\[\\da-fA-F]{1,6}"+M+"?|\\\\([^\\r\\n\\f])","g"),ne=function(e,t){var n="0x"+e.slice(1)-65536;return t||(n<0?String.fromCharCode(n+65536):String.fromCharCode(n>>10|55296,1023&n|56320))},re=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,ie=function(e,t){return t?"\0"===e?"\ufffd":e.slice(0,-1)+"\\"+e.charCodeAt(e.length-1).toString(16)+" ":"\\"+e},oe=function(){T()},ae=be(function(e){return!0===e.disabled&&"fieldset"===e.nodeName.toLowerCase()},{dir:"parentNode",next:"legend"});try{H.apply(t=O.call(p.childNodes),p.childNodes),t[p.childNodes.length].nodeType}catch(e){H={apply:t.length?function(e,t){L.apply(e,O.call(t))}:function(e,t){var n=e.length,r=0;while(e[n++]=t[r++]);e.length=n-1}}}function se(t,e,n,r){var i,o,a,s,u,l,c,f=e&&e.ownerDocument,p=e?e.nodeType:9;if(n=n||[],"string"!=typeof t||!t||1!==p&&9!==p&&11!==p)return n;if(!r&&(T(e),e=e||C,E)){if(11!==p&&(u=Z.exec(t)))if(i=u[1]){if(9===p){if(!(a=e.getElementById(i)))return n;if(a.id===i)return n.push(a),n}else if(f&&(a=f.getElementById(i))&&y(e,a)&&a.id===i)return n.push(a),n}else{if(u[2])return H.apply(n,e.getElementsByTagName(t)),n;if((i=u[3])&&d.getElementsByClassName&&e.getElementsByClassName)return H.apply(n,e.getElementsByClassName(i)),n}if(d.qsa&&!N[t+" "]&&(!v||!v.test(t))&&(1!==p||"object"!==e.nodeName.toLowerCase())){if(c=t,f=e,1===p&&(U.test(t)||z.test(t))){(f=ee.test(t)&&ye(e.parentNode)||e)===e&&d.scope||((s=e.getAttribute("id"))?s=s.replace(re,ie):e.setAttribute("id",s=S)),o=(l=h(t)).length;while(o--)l[o]=(s?"#"+s:":scope")+" "+xe(l[o]);c=l.join(",")}try{return H.apply(n,f.querySelectorAll(c)),n}catch(e){N(t,!0)}finally{s===S&&e.removeAttribute("id")}}}return g(t.replace($,"$1"),e,n,r)}function ue(){var r=[];return function e(t,n){return r.push(t+" ")>b.cacheLength&&delete e[r.shift()],e[t+" "]=n}}function le(e){return e[S]=!0,e}function ce(e){var t=C.createElement("fieldset");try{return!!e(t)}catch(e){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function fe(e,t){var n=e.split("|"),r=n.length;while(r--)b.attrHandle[n[r]]=t}function pe(e,t){var n=t&&e,r=n&&1===e.nodeType&&1===t.nodeType&&e.sourceIndex-t.sourceIndex;if(r)return r;if(n)while(n=n.nextSibling)if(n===t)return-1;return e?1:-1}function de(t){return function(e){return"input"===e.nodeName.toLowerCase()&&e.type===t}}function he(n){return function(e){var t=e.nodeName.toLowerCase();return("input"===t||"button"===t)&&e.type===n}}function ge(t){return function(e){return"form"in e?e.parentNode&&!1===e.disabled?"label"in e?"label"in e.parentNode?e.parentNode.disabled===t:e.disabled===t:e.isDisabled===t||e.isDisabled!==!t&&ae(e)===t:e.disabled===t:"label"in e&&e.disabled===t}}function ve(a){return le(function(o){return o=+o,le(function(e,t){var n,r=a([],e.length,o),i=r.length;while(i--)e[n=r[i]]&&(e[n]=!(t[n]=e[n]))})})}function ye(e){return e&&"undefined"!=typeof e.getElementsByTagName&&e}for(e in d=se.support={},i=se.isXML=function(e){var t=e&&e.namespaceURI,n=e&&(e.ownerDocument||e).documentElement;return!Y.test(t||n&&n.nodeName||"HTML")},T=se.setDocument=function(e){var t,n,r=e?e.ownerDocument||e:p;return r!=C&&9===r.nodeType&&r.documentElement&&(a=(C=r).documentElement,E=!i(C),p!=C&&(n=C.defaultView)&&n.top!==n&&(n.addEventListener?n.addEventListener("unload",oe,!1):n.attachEvent&&n.attachEvent("onunload",oe)),d.scope=ce(function(e){return a.appendChild(e).appendChild(C.createElement("div")),"undefined"!=typeof e.querySelectorAll&&!e.querySelectorAll(":scope fieldset div").length}),d.attributes=ce(function(e){return e.className="i",!e.getAttribute("className")}),d.getElementsByTagName=ce(function(e){return e.appendChild(C.createComment("")),!e.getElementsByTagName("*").length}),d.getElementsByClassName=K.test(C.getElementsByClassName),d.getById=ce(function(e){return a.appendChild(e).id=S,!C.getElementsByName||!C.getElementsByName(S).length}),d.getById?(b.filter.ID=function(e){var t=e.replace(te,ne);return function(e){return e.getAttribute("id")===t}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n=t.getElementById(e);return n?[n]:[]}}):(b.filter.ID=function(e){var n=e.replace(te,ne);return function(e){var t="undefined"!=typeof e.getAttributeNode&&e.getAttributeNode("id");return t&&t.value===n}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n,r,i,o=t.getElementById(e);if(o){if((n=o.getAttributeNode("id"))&&n.value===e)return[o];i=t.getElementsByName(e),r=0;while(o=i[r++])if((n=o.getAttributeNode("id"))&&n.value===e)return[o]}return[]}}),b.find.TAG=d.getElementsByTagName?function(e,t){return"undefined"!=typeof t.getElementsByTagName?t.getElementsByTagName(e):d.qsa?t.querySelectorAll(e):void 0}:function(e,t){var n,r=[],i=0,o=t.getElementsByTagName(e);if("*"===e){while(n=o[i++])1===n.nodeType&&r.push(n);return r}return o},b.find.CLASS=d.getElementsByClassName&&function(e,t){if("undefined"!=typeof t.getElementsByClassName&&E)return t.getElementsByClassName(e)},s=[],v=[],(d.qsa=K.test(C.querySelectorAll))&&(ce(function(e){var t;a.appendChild(e).innerHTML="<a id='"+S+"'></a><select id='"+S+"-\r\\' msallowcapture=''><option selected=''></option></select>",e.querySelectorAll("[msallowcapture^='']").length&&v.push("[*^$]="+M+"*(?:''|\"\")"),e.querySelectorAll("[selected]").length||v.push("\\["+M+"*(?:value|"+R+")"),e.querySelectorAll("[id~="+S+"-]").length||v.push("~="),(t=C.createElement("input")).setAttribute("name",""),e.appendChild(t),e.querySelectorAll("[name='']").length||v.push("\\["+M+"*name"+M+"*="+M+"*(?:''|\"\")"),e.querySelectorAll(":checked").length||v.push(":checked"),e.querySelectorAll("a#"+S+"+*").length||v.push(".#.+[+~]"),e.querySelectorAll("\\\f"),v.push("[\\r\\n\\f]")}),ce(function(e){e.innerHTML="<a href='' disabled='disabled'></a><select disabled='disabled'><option/></select>";var t=C.createElement("input");t.setAttribute("type","hidden"),e.appendChild(t).setAttribute("name","D"),e.querySelectorAll("[name=d]").length&&v.push("name"+M+"*[*^$|!~]?="),2!==e.querySelectorAll(":enabled").length&&v.push(":enabled",":disabled"),a.appendChild(e).disabled=!0,2!==e.querySelectorAll(":disabled").length&&v.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),v.push(",.*:")})),(d.matchesSelector=K.test(c=a.matches||a.webkitMatchesSelector||a.mozMatchesSelector||a.oMatchesSelector||a.msMatchesSelector))&&ce(function(e){d.disconnectedMatch=c.call(e,"*"),c.call(e,"[s!='']:x"),s.push("!=",F)}),v=v.length&&new RegExp(v.join("|")),s=s.length&&new RegExp(s.join("|")),t=K.test(a.compareDocumentPosition),y=t||K.test(a.contains)?function(e,t){var n=9===e.nodeType?e.documentElement:e,r=t&&t.parentNode;return e===r||!(!r||1!==r.nodeType||!(n.contains?n.contains(r):e.compareDocumentPosition&&16&e.compareDocumentPosition(r)))}:function(e,t){if(t)while(t=t.parentNode)if(t===e)return!0;return!1},j=t?function(e,t){if(e===t)return l=!0,0;var n=!e.compareDocumentPosition-!t.compareDocumentPosition;return n||(1&(n=(e.ownerDocument||e)==(t.ownerDocument||t)?e.compareDocumentPosition(t):1)||!d.sortDetached&&t.compareDocumentPosition(e)===n?e==C||e.ownerDocument==p&&y(p,e)?-1:t==C||t.ownerDocument==p&&y(p,t)?1:u?P(u,e)-P(u,t):0:4&n?-1:1)}:function(e,t){if(e===t)return l=!0,0;var n,r=0,i=e.parentNode,o=t.parentNode,a=[e],s=[t];if(!i||!o)return e==C?-1:t==C?1:i?-1:o?1:u?P(u,e)-P(u,t):0;if(i===o)return pe(e,t);n=e;while(n=n.parentNode)a.unshift(n);n=t;while(n=n.parentNode)s.unshift(n);while(a[r]===s[r])r++;return r?pe(a[r],s[r]):a[r]==p?-1:s[r]==p?1:0}),C},se.matches=function(e,t){return se(e,null,null,t)},se.matchesSelector=function(e,t){if(T(e),d.matchesSelector&&E&&!N[t+" "]&&(!s||!s.test(t))&&(!v||!v.test(t)))try{var n=c.call(e,t);if(n||d.disconnectedMatch||e.document&&11!==e.document.nodeType)return n}catch(e){N(t,!0)}return 0<se(t,C,null,[e]).length},se.contains=function(e,t){return(e.ownerDocument||e)!=C&&T(e),y(e,t)},se.attr=function(e,t){(e.ownerDocument||e)!=C&&T(e);var n=b.attrHandle[t.toLowerCase()],r=n&&D.call(b.attrHandle,t.toLowerCase())?n(e,t,!E):void 0;return void 0!==r?r:d.attributes||!E?e.getAttribute(t):(r=e.getAttributeNode(t))&&r.specified?r.value:null},se.escape=function(e){return(e+"").replace(re,ie)},se.error=function(e){throw new Error("Syntax error, unrecognized expression: "+e)},se.uniqueSort=function(e){var t,n=[],r=0,i=0;if(l=!d.detectDuplicates,u=!d.sortStable&&e.slice(0),e.sort(j),l){while(t=e[i++])t===e[i]&&(r=n.push(i));while(r--)e.splice(n[r],1)}return u=null,e},o=se.getText=function(e){var t,n="",r=0,i=e.nodeType;if(i){if(1===i||9===i||11===i){if("string"==typeof e.textContent)return e.textContent;for(e=e.firstChild;e;e=e.nextSibling)n+=o(e)}else if(3===i||4===i)return e.nodeValue}else while(t=e[r++])n+=o(t);return n},(b=se.selectors={cacheLength:50,createPseudo:le,match:G,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(te,ne),e[3]=(e[3]||e[4]||e[5]||"").replace(te,ne),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||se.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&se.error(e[0]),e},PSEUDO:function(e){var t,n=!e[6]&&e[2];return G.CHILD.test(e[0])?null:(e[3]?e[2]=e[4]||e[5]||"":n&&X.test(n)&&(t=h(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(te,ne).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=m[e+" "];return t||(t=new RegExp("(^|"+M+")"+e+"("+M+"|$)"))&&m(e,function(e){return t.test("string"==typeof e.className&&e.className||"undefined"!=typeof e.getAttribute&&e.getAttribute("class")||"")})},ATTR:function(n,r,i){return function(e){var t=se.attr(e,n);return null==t?"!="===r:!r||(t+="","="===r?t===i:"!="===r?t!==i:"^="===r?i&&0===t.indexOf(i):"*="===r?i&&-1<t.indexOf(i):"$="===r?i&&t.slice(-i.length)===i:"~="===r?-1<(" "+t.replace(B," ")+" ").indexOf(i):"|="===r&&(t===i||t.slice(0,i.length+1)===i+"-"))}},CHILD:function(h,e,t,g,v){var y="nth"!==h.slice(0,3),m="last"!==h.slice(-4),x="of-type"===e;return 1===g&&0===v?function(e){return!!e.parentNode}:function(e,t,n){var r,i,o,a,s,u,l=y!==m?"nextSibling":"previousSibling",c=e.parentNode,f=x&&e.nodeName.toLowerCase(),p=!n&&!x,d=!1;if(c){if(y){while(l){a=e;while(a=a[l])if(x?a.nodeName.toLowerCase()===f:1===a.nodeType)return!1;u=l="only"===h&&!u&&"nextSibling"}return!0}if(u=[m?c.firstChild:c.lastChild],m&&p){d=(s=(r=(i=(o=(a=c)[S]||(a[S]={}))[a.uniqueID]||(o[a.uniqueID]={}))[h]||[])[0]===k&&r[1])&&r[2],a=s&&c.childNodes[s];while(a=++s&&a&&a[l]||(d=s=0)||u.pop())if(1===a.nodeType&&++d&&a===e){i[h]=[k,s,d];break}}else if(p&&(d=s=(r=(i=(o=(a=e)[S]||(a[S]={}))[a.uniqueID]||(o[a.uniqueID]={}))[h]||[])[0]===k&&r[1]),!1===d)while(a=++s&&a&&a[l]||(d=s=0)||u.pop())if((x?a.nodeName.toLowerCase()===f:1===a.nodeType)&&++d&&(p&&((i=(o=a[S]||(a[S]={}))[a.uniqueID]||(o[a.uniqueID]={}))[h]=[k,d]),a===e))break;return(d-=v)===g||d%g==0&&0<=d/g}}},PSEUDO:function(e,o){var t,a=b.pseudos[e]||b.setFilters[e.toLowerCase()]||se.error("unsupported pseudo: "+e);return a[S]?a(o):1<a.length?(t=[e,e,"",o],b.setFilters.hasOwnProperty(e.toLowerCase())?le(function(e,t){var n,r=a(e,o),i=r.length;while(i--)e[n=P(e,r[i])]=!(t[n]=r[i])}):function(e){return a(e,0,t)}):a}},pseudos:{not:le(function(e){var r=[],i=[],s=f(e.replace($,"$1"));return s[S]?le(function(e,t,n,r){var i,o=s(e,null,r,[]),a=e.length;while(a--)(i=o[a])&&(e[a]=!(t[a]=i))}):function(e,t,n){return r[0]=e,s(r,null,n,i),r[0]=null,!i.pop()}}),has:le(function(t){return function(e){return 0<se(t,e).length}}),contains:le(function(t){return t=t.replace(te,ne),function(e){return-1<(e.textContent||o(e)).indexOf(t)}}),lang:le(function(n){return V.test(n||"")||se.error("unsupported lang: "+n),n=n.replace(te,ne).toLowerCase(),function(e){var t;do{if(t=E?e.lang:e.getAttribute("xml:lang")||e.getAttribute("lang"))return(t=t.toLowerCase())===n||0===t.indexOf(n+"-")}while((e=e.parentNode)&&1===e.nodeType);return!1}}),target:function(e){var t=n.location&&n.location.hash;return t&&t.slice(1)===e.id},root:function(e){return e===a},focus:function(e){return e===C.activeElement&&(!C.hasFocus||C.hasFocus())&&!!(e.type||e.href||~e.tabIndex)},enabled:ge(!1),disabled:ge(!0),checked:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&!!e.checked||"option"===t&&!!e.selected},selected:function(e){return e.parentNode&&e.parentNode.selectedIndex,!0===e.selected},empty:function(e){for(e=e.firstChild;e;e=e.nextSibling)if(e.nodeType<6)return!1;return!0},parent:function(e){return!b.pseudos.empty(e)},header:function(e){return J.test(e.nodeName)},input:function(e){return Q.test(e.nodeName)},button:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&"button"===e.type||"button"===t},text:function(e){var t;return"input"===e.nodeName.toLowerCase()&&"text"===e.type&&(null==(t=e.getAttribute("type"))||"text"===t.toLowerCase())},first:ve(function(){return[0]}),last:ve(function(e,t){return[t-1]}),eq:ve(function(e,t,n){return[n<0?n+t:n]}),even:ve(function(e,t){for(var n=0;n<t;n+=2)e.push(n);return e}),odd:ve(function(e,t){for(var n=1;n<t;n+=2)e.push(n);return e}),lt:ve(function(e,t,n){for(var r=n<0?n+t:t<n?t:n;0<=--r;)e.push(r);return e}),gt:ve(function(e,t,n){for(var r=n<0?n+t:n;++r<t;)e.push(r);return e})}}).pseudos.nth=b.pseudos.eq,{radio:!0,checkbox:!0,file:!0,password:!0,image:!0})b.pseudos[e]=de(e);for(e in{submit:!0,reset:!0})b.pseudos[e]=he(e);function me(){}function xe(e){for(var t=0,n=e.length,r="";t<n;t++)r+=e[t].value;return r}function be(s,e,t){var u=e.dir,l=e.next,c=l||u,f=t&&"parentNode"===c,p=r++;return e.first?function(e,t,n){while(e=e[u])if(1===e.nodeType||f)return s(e,t,n);return!1}:function(e,t,n){var r,i,o,a=[k,p];if(n){while(e=e[u])if((1===e.nodeType||f)&&s(e,t,n))return!0}else while(e=e[u])if(1===e.nodeType||f)if(i=(o=e[S]||(e[S]={}))[e.uniqueID]||(o[e.uniqueID]={}),l&&l===e.nodeName.toLowerCase())e=e[u]||e;else{if((r=i[c])&&r[0]===k&&r[1]===p)return a[2]=r[2];if((i[c]=a)[2]=s(e,t,n))return!0}return!1}}function we(i){return 1<i.length?function(e,t,n){var r=i.length;while(r--)if(!i[r](e,t,n))return!1;return!0}:i[0]}function Te(e,t,n,r,i){for(var o,a=[],s=0,u=e.length,l=null!=t;s<u;s++)(o=e[s])&&(n&&!n(o,r,i)||(a.push(o),l&&t.push(s)));return a}function Ce(d,h,g,v,y,e){return v&&!v[S]&&(v=Ce(v)),y&&!y[S]&&(y=Ce(y,e)),le(function(e,t,n,r){var i,o,a,s=[],u=[],l=t.length,c=e||function(e,t,n){for(var r=0,i=t.length;r<i;r++)se(e,t[r],n);return n}(h||"*",n.nodeType?[n]:n,[]),f=!d||!e&&h?c:Te(c,s,d,n,r),p=g?y||(e?d:l||v)?[]:t:f;if(g&&g(f,p,n,r),v){i=Te(p,u),v(i,[],n,r),o=i.length;while(o--)(a=i[o])&&(p[u[o]]=!(f[u[o]]=a))}if(e){if(y||d){if(y){i=[],o=p.length;while(o--)(a=p[o])&&i.push(f[o]=a);y(null,p=[],i,r)}o=p.length;while(o--)(a=p[o])&&-1<(i=y?P(e,a):s[o])&&(e[i]=!(t[i]=a))}}else p=Te(p===t?p.splice(l,p.length):p),y?y(null,t,p,r):H.apply(t,p)})}function Ee(e){for(var i,t,n,r=e.length,o=b.relative[e[0].type],a=o||b.relative[" "],s=o?1:0,u=be(function(e){return e===i},a,!0),l=be(function(e){return-1<P(i,e)},a,!0),c=[function(e,t,n){var r=!o&&(n||t!==w)||((i=t).nodeType?u(e,t,n):l(e,t,n));return i=null,r}];s<r;s++)if(t=b.relative[e[s].type])c=[be(we(c),t)];else{if((t=b.filter[e[s].type].apply(null,e[s].matches))[S]){for(n=++s;n<r;n++)if(b.relative[e[n].type])break;return Ce(1<s&&we(c),1<s&&xe(e.slice(0,s-1).concat({value:" "===e[s-2].type?"*":""})).replace($,"$1"),t,s<n&&Ee(e.slice(s,n)),n<r&&Ee(e=e.slice(n)),n<r&&xe(e))}c.push(t)}return we(c)}return me.prototype=b.filters=b.pseudos,b.setFilters=new me,h=se.tokenize=function(e,t){var n,r,i,o,a,s,u,l=x[e+" "];if(l)return t?0:l.slice(0);a=e,s=[],u=b.preFilter;while(a){for(o in n&&!(r=_.exec(a))||(r&&(a=a.slice(r[0].length)||a),s.push(i=[])),n=!1,(r=z.exec(a))&&(n=r.shift(),i.push({value:n,type:r[0].replace($," ")}),a=a.slice(n.length)),b.filter)!(r=G[o].exec(a))||u[o]&&!(r=u[o](r))||(n=r.shift(),i.push({value:n,type:o,matches:r}),a=a.slice(n.length));if(!n)break}return t?a.length:a?se.error(e):x(e,s).slice(0)},f=se.compile=function(e,t){var n,v,y,m,x,r,i=[],o=[],a=A[e+" "];if(!a){t||(t=h(e)),n=t.length;while(n--)(a=Ee(t[n]))[S]?i.push(a):o.push(a);(a=A(e,(v=o,m=0<(y=i).length,x=0<v.length,r=function(e,t,n,r,i){var o,a,s,u=0,l="0",c=e&&[],f=[],p=w,d=e||x&&b.find.TAG("*",i),h=k+=null==p?1:Math.random()||.1,g=d.length;for(i&&(w=t==C||t||i);l!==g&&null!=(o=d[l]);l++){if(x&&o){a=0,t||o.ownerDocument==C||(T(o),n=!E);while(s=v[a++])if(s(o,t||C,n)){r.push(o);break}i&&(k=h)}m&&((o=!s&&o)&&u--,e&&c.push(o))}if(u+=l,m&&l!==u){a=0;while(s=y[a++])s(c,f,t,n);if(e){if(0<u)while(l--)c[l]||f[l]||(f[l]=q.call(r));f=Te(f)}H.apply(r,f),i&&!e&&0<f.length&&1<u+y.length&&se.uniqueSort(r)}return i&&(k=h,w=p),c},m?le(r):r))).selector=e}return a},g=se.select=function(e,t,n,r){var i,o,a,s,u,l="function"==typeof e&&e,c=!r&&h(e=l.selector||e);if(n=n||[],1===c.length){if(2<(o=c[0]=c[0].slice(0)).length&&"ID"===(a=o[0]).type&&9===t.nodeType&&E&&b.relative[o[1].type]){if(!(t=(b.find.ID(a.matches[0].replace(te,ne),t)||[])[0]))return n;l&&(t=t.parentNode),e=e.slice(o.shift().value.length)}i=G.needsContext.test(e)?0:o.length;while(i--){if(a=o[i],b.relative[s=a.type])break;if((u=b.find[s])&&(r=u(a.matches[0].replace(te,ne),ee.test(o[0].type)&&ye(t.parentNode)||t))){if(o.splice(i,1),!(e=r.length&&xe(o)))return H.apply(n,r),n;break}}}return(l||f(e,c))(r,t,!E,n,!t||ee.test(e)&&ye(t.parentNode)||t),n},d.sortStable=S.split("").sort(j).join("")===S,d.detectDuplicates=!!l,T(),d.sortDetached=ce(function(e){return 1&e.compareDocumentPosition(C.createElement("fieldset"))}),ce(function(e){return e.innerHTML="<a href='#'></a>","#"===e.firstChild.getAttribute("href")})||fe("type|href|height|width",function(e,t,n){if(!n)return e.getAttribute(t,"type"===t.toLowerCase()?1:2)}),d.attributes&&ce(function(e){return e.innerHTML="<input/>",e.firstChild.setAttribute("value",""),""===e.firstChild.getAttribute("value")})||fe("value",function(e,t,n){if(!n&&"input"===e.nodeName.toLowerCase())return e.defaultValue}),ce(function(e){return null==e.getAttribute("disabled")})||fe(R,function(e,t,n){var r;if(!n)return!0===e[t]?t.toLowerCase():(r=e.getAttributeNode(t))&&r.specified?r.value:null}),se}(C);S.find=d,S.expr=d.selectors,S.expr[":"]=S.expr.pseudos,S.uniqueSort=S.unique=d.uniqueSort,S.text=d.getText,S.isXMLDoc=d.isXML,S.contains=d.contains,S.escapeSelector=d.escape;var h=function(e,t,n){var r=[],i=void 0!==n;while((e=e[t])&&9!==e.nodeType)if(1===e.nodeType){if(i&&S(e).is(n))break;r.push(e)}return r},T=function(e,t){for(var n=[];e;e=e.nextSibling)1===e.nodeType&&e!==t&&n.push(e);return n},k=S.expr.match.needsContext;function A(e,t){return e.nodeName&&e.nodeName.toLowerCase()===t.toLowerCase()}var N=/^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;function j(e,n,r){return m(n)?S.grep(e,function(e,t){return!!n.call(e,t,e)!==r}):n.nodeType?S.grep(e,function(e){return e===n!==r}):"string"!=typeof n?S.grep(e,function(e){return-1<i.call(n,e)!==r}):S.filter(n,e,r)}S.filter=function(e,t,n){var r=t[0];return n&&(e=":not("+e+")"),1===t.length&&1===r.nodeType?S.find.matchesSelector(r,e)?[r]:[]:S.find.matches(e,S.grep(t,function(e){return 1===e.nodeType}))},S.fn.extend({find:function(e){var t,n,r=this.length,i=this;if("string"!=typeof e)return this.pushStack(S(e).filter(function(){for(t=0;t<r;t++)if(S.contains(i[t],this))return!0}));for(n=this.pushStack([]),t=0;t<r;t++)S.find(e,i[t],n);return 1<r?S.uniqueSort(n):n},filter:function(e){return this.pushStack(j(this,e||[],!1))},not:function(e){return this.pushStack(j(this,e||[],!0))},is:function(e){return!!j(this,"string"==typeof e&&k.test(e)?S(e):e||[],!1).length}});var D,q=/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/;(S.fn.init=function(e,t,n){var r,i;if(!e)return this;if(n=n||D,"string"==typeof e){if(!(r="<"===e[0]&&">"===e[e.length-1]&&3<=e.length?[null,e,null]:q.exec(e))||!r[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(r[1]){if(t=t instanceof S?t[0]:t,S.merge(this,S.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:E,!0)),N.test(r[1])&&S.isPlainObject(t))for(r in t)m(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return(i=E.getElementById(r[2]))&&(this[0]=i,this.length=1),this}return e.nodeType?(this[0]=e,this.length=1,this):m(e)?void 0!==n.ready?n.ready(e):e(S):S.makeArray(e,this)}).prototype=S.fn,D=S(E);var L=/^(?:parents|prev(?:Until|All))/,H={children:!0,contents:!0,next:!0,prev:!0};function O(e,t){while((e=e[t])&&1!==e.nodeType);return e}S.fn.extend({has:function(e){var t=S(e,this),n=t.length;return this.filter(function(){for(var e=0;e<n;e++)if(S.contains(this,t[e]))return!0})},closest:function(e,t){var n,r=0,i=this.length,o=[],a="string"!=typeof e&&S(e);if(!k.test(e))for(;r<i;r++)for(n=this[r];n&&n!==t;n=n.parentNode)if(n.nodeType<11&&(a?-1<a.index(n):1===n.nodeType&&S.find.matchesSelector(n,e))){o.push(n);break}return this.pushStack(1<o.length?S.uniqueSort(o):o)},index:function(e){return e?"string"==typeof e?i.call(S(e),this[0]):i.call(this,e.jquery?e[0]:e):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(e,t){return this.pushStack(S.uniqueSort(S.merge(this.get(),S(e,t))))},addBack:function(e){return this.add(null==e?this.prevObject:this.prevObject.filter(e))}}),S.each({parent:function(e){var t=e.parentNode;return t&&11!==t.nodeType?t:null},parents:function(e){return h(e,"parentNode")},parentsUntil:function(e,t,n){return h(e,"parentNode",n)},next:function(e){return O(e,"nextSibling")},prev:function(e){return O(e,"previousSibling")},nextAll:function(e){return h(e,"nextSibling")},prevAll:function(e){return h(e,"previousSibling")},nextUntil:function(e,t,n){return h(e,"nextSibling",n)},prevUntil:function(e,t,n){return h(e,"previousSibling",n)},siblings:function(e){return T((e.parentNode||{}).firstChild,e)},children:function(e){return T(e.firstChild)},contents:function(e){return null!=e.contentDocument&&r(e.contentDocument)?e.contentDocument:(A(e,"template")&&(e=e.content||e),S.merge([],e.childNodes))}},function(r,i){S.fn[r]=function(e,t){var n=S.map(this,i,e);return"Until"!==r.slice(-5)&&(t=e),t&&"string"==typeof t&&(n=S.filter(t,n)),1<this.length&&(H[r]||S.uniqueSort(n),L.test(r)&&n.reverse()),this.pushStack(n)}});var P=/[^\x20\t\r\n\f]+/g;function R(e){return e}function M(e){throw e}function I(e,t,n,r){var i;try{e&&m(i=e.promise)?i.call(e).done(t).fail(n):e&&m(i=e.then)?i.call(e,t,n):t.apply(void 0,[e].slice(r))}catch(e){n.apply(void 0,[e])}}S.Callbacks=function(r){var e,n;r="string"==typeof r?(e=r,n={},S.each(e.match(P)||[],function(e,t){n[t]=!0}),n):S.extend({},r);var i,t,o,a,s=[],u=[],l=-1,c=function(){for(a=a||r.once,o=i=!0;u.length;l=-1){t=u.shift();while(++l<s.length)!1===s[l].apply(t[0],t[1])&&r.stopOnFalse&&(l=s.length,t=!1)}r.memory||(t=!1),i=!1,a&&(s=t?[]:"")},f={add:function(){return s&&(t&&!i&&(l=s.length-1,u.push(t)),function n(e){S.each(e,function(e,t){m(t)?r.unique&&f.has(t)||s.push(t):t&&t.length&&"string"!==w(t)&&n(t)})}(arguments),t&&!i&&c()),this},remove:function(){return S.each(arguments,function(e,t){var n;while(-1<(n=S.inArray(t,s,n)))s.splice(n,1),n<=l&&l--}),this},has:function(e){return e?-1<S.inArray(e,s):0<s.length},empty:function(){return s&&(s=[]),this},disable:function(){return a=u=[],s=t="",this},disabled:function(){return!s},lock:function(){return a=u=[],t||i||(s=t=""),this},locked:function(){return!!a},fireWith:function(e,t){return a||(t=[e,(t=t||[]).slice?t.slice():t],u.push(t),i||c()),this},fire:function(){return f.fireWith(this,arguments),this},fired:function(){return!!o}};return f},S.extend({Deferred:function(e){var o=[["notify","progress",S.Callbacks("memory"),S.Callbacks("memory"),2],["resolve","done",S.Callbacks("once memory"),S.Callbacks("once memory"),0,"resolved"],["reject","fail",S.Callbacks("once memory"),S.Callbacks("once memory"),1,"rejected"]],i="pending",a={state:function(){return i},always:function(){return s.done(arguments).fail(arguments),this},"catch":function(e){return a.then(null,e)},pipe:function(){var i=arguments;return S.Deferred(function(r){S.each(o,function(e,t){var n=m(i[t[4]])&&i[t[4]];s[t[1]](function(){var e=n&&n.apply(this,arguments);e&&m(e.promise)?e.promise().progress(r.notify).done(r.resolve).fail(r.reject):r[t[0]+"With"](this,n?[e]:arguments)})}),i=null}).promise()},then:function(t,n,r){var u=0;function l(i,o,a,s){return function(){var n=this,r=arguments,e=function(){var e,t;if(!(i<u)){if((e=a.apply(n,r))===o.promise())throw new TypeError("Thenable self-resolution");t=e&&("object"==typeof e||"function"==typeof e)&&e.then,m(t)?s?t.call(e,l(u,o,R,s),l(u,o,M,s)):(u++,t.call(e,l(u,o,R,s),l(u,o,M,s),l(u,o,R,o.notifyWith))):(a!==R&&(n=void 0,r=[e]),(s||o.resolveWith)(n,r))}},t=s?e:function(){try{e()}catch(e){S.Deferred.exceptionHook&&S.Deferred.exceptionHook(e,t.stackTrace),u<=i+1&&(a!==M&&(n=void 0,r=[e]),o.rejectWith(n,r))}};i?t():(S.Deferred.getStackHook&&(t.stackTrace=S.Deferred.getStackHook()),C.setTimeout(t))}}return S.Deferred(function(e){o[0][3].add(l(0,e,m(r)?r:R,e.notifyWith)),o[1][3].add(l(0,e,m(t)?t:R)),o[2][3].add(l(0,e,m(n)?n:M))}).promise()},promise:function(e){return null!=e?S.extend(e,a):a}},s={};return S.each(o,function(e,t){var n=t[2],r=t[5];a[t[1]]=n.add,r&&n.add(function(){i=r},o[3-e][2].disable,o[3-e][3].disable,o[0][2].lock,o[0][3].lock),n.add(t[3].fire),s[t[0]]=function(){return s[t[0]+"With"](this===s?void 0:this,arguments),this},s[t[0]+"With"]=n.fireWith}),a.promise(s),e&&e.call(s,s),s},when:function(e){var n=arguments.length,t=n,r=Array(t),i=s.call(arguments),o=S.Deferred(),a=function(t){return function(e){r[t]=this,i[t]=1<arguments.length?s.call(arguments):e,--n||o.resolveWith(r,i)}};if(n<=1&&(I(e,o.done(a(t)).resolve,o.reject,!n),"pending"===o.state()||m(i[t]&&i[t].then)))return o.then();while(t--)I(i[t],a(t),o.reject);return o.promise()}});var W=/^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;S.Deferred.exceptionHook=function(e,t){C.console&&C.console.warn&&e&&W.test(e.name)&&C.console.warn("jQuery.Deferred exception: "+e.message,e.stack,t)},S.readyException=function(e){C.setTimeout(function(){throw e})};var F=S.Deferred();function B(){E.removeEventListener("DOMContentLoaded",B),C.removeEventListener("load",B),S.ready()}S.fn.ready=function(e){return F.then(e)["catch"](function(e){S.readyException(e)}),this},S.extend({isReady:!1,readyWait:1,ready:function(e){(!0===e?--S.readyWait:S.isReady)||(S.isReady=!0)!==e&&0<--S.readyWait||F.resolveWith(E,[S])}}),S.ready.then=F.then,"complete"===E.readyState||"loading"!==E.readyState&&!E.documentElement.doScroll?C.setTimeout(S.ready):(E.addEventListener("DOMContentLoaded",B),C.addEventListener("load",B));var $=function(e,t,n,r,i,o,a){var s=0,u=e.length,l=null==n;if("object"===w(n))for(s in i=!0,n)$(e,t,s,n[s],!0,o,a);else if(void 0!==r&&(i=!0,m(r)||(a=!0),l&&(a?(t.call(e,r),t=null):(l=t,t=function(e,t,n){return l.call(S(e),n)})),t))for(;s<u;s++)t(e[s],n,a?r:r.call(e[s],s,t(e[s],n)));return i?e:l?t.call(e):u?t(e[0],n):o},_=/^-ms-/,z=/-([a-z])/g;function U(e,t){return t.toUpperCase()}function X(e){return e.replace(_,"ms-").replace(z,U)}var V=function(e){return 1===e.nodeType||9===e.nodeType||!+e.nodeType};function G(){this.expando=S.expando+G.uid++}G.uid=1,G.prototype={cache:function(e){var t=e[this.expando];return t||(t={},V(e)&&(e.nodeType?e[this.expando]=t:Object.defineProperty(e,this.expando,{value:t,configurable:!0}))),t},set:function(e,t,n){var r,i=this.cache(e);if("string"==typeof t)i[X(t)]=n;else for(r in t)i[X(r)]=t[r];return i},get:function(e,t){return void 0===t?this.cache(e):e[this.expando]&&e[this.expando][X(t)]},access:function(e,t,n){return void 0===t||t&&"string"==typeof t&&void 0===n?this.get(e,t):(this.set(e,t,n),void 0!==n?n:t)},remove:function(e,t){var n,r=e[this.expando];if(void 0!==r){if(void 0!==t){n=(t=Array.isArray(t)?t.map(X):(t=X(t))in r?[t]:t.match(P)||[]).length;while(n--)delete r[t[n]]}(void 0===t||S.isEmptyObject(r))&&(e.nodeType?e[this.expando]=void 0:delete e[this.expando])}},hasData:function(e){var t=e[this.expando];return void 0!==t&&!S.isEmptyObject(t)}};var Y=new G,Q=new G,J=/^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,K=/[A-Z]/g;function Z(e,t,n){var r,i;if(void 0===n&&1===e.nodeType)if(r="data-"+t.replace(K,"-$&").toLowerCase(),"string"==typeof(n=e.getAttribute(r))){try{n="true"===(i=n)||"false"!==i&&("null"===i?null:i===+i+""?+i:J.test(i)?JSON.parse(i):i)}catch(e){}Q.set(e,t,n)}else n=void 0;return n}S.extend({hasData:function(e){return Q.hasData(e)||Y.hasData(e)},data:function(e,t,n){return Q.access(e,t,n)},removeData:function(e,t){Q.remove(e,t)},_data:function(e,t,n){return Y.access(e,t,n)},_removeData:function(e,t){Y.remove(e,t)}}),S.fn.extend({data:function(n,e){var t,r,i,o=this[0],a=o&&o.attributes;if(void 0===n){if(this.length&&(i=Q.get(o),1===o.nodeType&&!Y.get(o,"hasDataAttrs"))){t=a.length;while(t--)a[t]&&0===(r=a[t].name).indexOf("data-")&&(r=X(r.slice(5)),Z(o,r,i[r]));Y.set(o,"hasDataAttrs",!0)}return i}return"object"==typeof n?this.each(function(){Q.set(this,n)}):$(this,function(e){var t;if(o&&void 0===e)return void 0!==(t=Q.get(o,n))?t:void 0!==(t=Z(o,n))?t:void 0;this.each(function(){Q.set(this,n,e)})},null,e,1<arguments.length,null,!0)},removeData:function(e){return this.each(function(){Q.remove(this,e)})}}),S.extend({queue:function(e,t,n){var r;if(e)return t=(t||"fx")+"queue",r=Y.get(e,t),n&&(!r||Array.isArray(n)?r=Y.access(e,t,S.makeArray(n)):r.push(n)),r||[]},dequeue:function(e,t){t=t||"fx";var n=S.queue(e,t),r=n.length,i=n.shift(),o=S._queueHooks(e,t);"inprogress"===i&&(i=n.shift(),r--),i&&("fx"===t&&n.unshift("inprogress"),delete o.stop,i.call(e,function(){S.dequeue(e,t)},o)),!r&&o&&o.empty.fire()},_queueHooks:function(e,t){var n=t+"queueHooks";return Y.get(e,n)||Y.access(e,n,{empty:S.Callbacks("once memory").add(function(){Y.remove(e,[t+"queue",n])})})}}),S.fn.extend({queue:function(t,n){var e=2;return"string"!=typeof t&&(n=t,t="fx",e--),arguments.length<e?S.queue(this[0],t):void 0===n?this:this.each(function(){var e=S.queue(this,t,n);S._queueHooks(this,t),"fx"===t&&"inprogress"!==e[0]&&S.dequeue(this,t)})},dequeue:function(e){return this.each(function(){S.dequeue(this,e)})},clearQueue:function(e){return this.queue(e||"fx",[])},promise:function(e,t){var n,r=1,i=S.Deferred(),o=this,a=this.length,s=function(){--r||i.resolveWith(o,[o])};"string"!=typeof e&&(t=e,e=void 0),e=e||"fx";while(a--)(n=Y.get(o[a],e+"queueHooks"))&&n.empty&&(r++,n.empty.add(s));return s(),i.promise(t)}});var ee=/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,te=new RegExp("^(?:([+-])=|)("+ee+")([a-z%]*)$","i"),ne=["Top","Right","Bottom","Left"],re=E.documentElement,ie=function(e){return S.contains(e.ownerDocument,e)},oe={composed:!0};re.getRootNode&&(ie=function(e){return S.contains(e.ownerDocument,e)||e.getRootNode(oe)===e.ownerDocument});var ae=function(e,t){return"none"===(e=t||e).style.display||""===e.style.display&&ie(e)&&"none"===S.css(e,"display")};function se(e,t,n,r){var i,o,a=20,s=r?function(){return r.cur()}:function(){return S.css(e,t,"")},u=s(),l=n&&n[3]||(S.cssNumber[t]?"":"px"),c=e.nodeType&&(S.cssNumber[t]||"px"!==l&&+u)&&te.exec(S.css(e,t));if(c&&c[3]!==l){u/=2,l=l||c[3],c=+u||1;while(a--)S.style(e,t,c+l),(1-o)*(1-(o=s()/u||.5))<=0&&(a=0),c/=o;c*=2,S.style(e,t,c+l),n=n||[]}return n&&(c=+c||+u||0,i=n[1]?c+(n[1]+1)*n[2]:+n[2],r&&(r.unit=l,r.start=c,r.end=i)),i}var ue={};function le(e,t){for(var n,r,i,o,a,s,u,l=[],c=0,f=e.length;c<f;c++)(r=e[c]).style&&(n=r.style.display,t?("none"===n&&(l[c]=Y.get(r,"display")||null,l[c]||(r.style.display="")),""===r.style.display&&ae(r)&&(l[c]=(u=a=o=void 0,a=(i=r).ownerDocument,s=i.nodeName,(u=ue[s])||(o=a.body.appendChild(a.createElement(s)),u=S.css(o,"display"),o.parentNode.removeChild(o),"none"===u&&(u="block"),ue[s]=u)))):"none"!==n&&(l[c]="none",Y.set(r,"display",n)));for(c=0;c<f;c++)null!=l[c]&&(e[c].style.display=l[c]);return e}S.fn.extend({show:function(){return le(this,!0)},hide:function(){return le(this)},toggle:function(e){return"boolean"==typeof e?e?this.show():this.hide():this.each(function(){ae(this)?S(this).show():S(this).hide()})}});var ce,fe,pe=/^(?:checkbox|radio)$/i,de=/<([a-z][^\/\0>\x20\t\r\n\f]*)/i,he=/^$|^module$|\/(?:java|ecma)script/i;ce=E.createDocumentFragment().appendChild(E.createElement("div")),(fe=E.createElement("input")).setAttribute("type","radio"),fe.setAttribute("checked","checked"),fe.setAttribute("name","t"),ce.appendChild(fe),y.checkClone=ce.cloneNode(!0).cloneNode(!0).lastChild.checked,ce.innerHTML="<textarea>x</textarea>",y.noCloneChecked=!!ce.cloneNode(!0).lastChild.defaultValue,ce.innerHTML="<option></option>",y.option=!!ce.lastChild;var ge={thead:[1,"<table>","</table>"],col:[2,"<table><colgroup>","</colgroup></table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],_default:[0,"",""]};function ve(e,t){var n;return n="undefined"!=typeof e.getElementsByTagName?e.getElementsByTagName(t||"*"):"undefined"!=typeof e.querySelectorAll?e.querySelectorAll(t||"*"):[],void 0===t||t&&A(e,t)?S.merge([e],n):n}function ye(e,t){for(var n=0,r=e.length;n<r;n++)Y.set(e[n],"globalEval",!t||Y.get(t[n],"globalEval"))}ge.tbody=ge.tfoot=ge.colgroup=ge.caption=ge.thead,ge.th=ge.td,y.option||(ge.optgroup=ge.option=[1,"<select multiple='multiple'>","</select>"]);var me=/<|&#?\w+;/;function xe(e,t,n,r,i){for(var o,a,s,u,l,c,f=t.createDocumentFragment(),p=[],d=0,h=e.length;d<h;d++)if((o=e[d])||0===o)if("object"===w(o))S.merge(p,o.nodeType?[o]:o);else if(me.test(o)){a=a||f.appendChild(t.createElement("div")),s=(de.exec(o)||["",""])[1].toLowerCase(),u=ge[s]||ge._default,a.innerHTML=u[1]+S.htmlPrefilter(o)+u[2],c=u[0];while(c--)a=a.lastChild;S.merge(p,a.childNodes),(a=f.firstChild).textContent=""}else p.push(t.createTextNode(o));f.textContent="",d=0;while(o=p[d++])if(r&&-1<S.inArray(o,r))i&&i.push(o);else if(l=ie(o),a=ve(f.appendChild(o),"script"),l&&ye(a),n){c=0;while(o=a[c++])he.test(o.type||"")&&n.push(o)}return f}var be=/^([^.]*)(?:\.(.+)|)/;function we(){return!0}function Te(){return!1}function Ce(e,t){return e===function(){try{return E.activeElement}catch(e){}}()==("focus"===t)}function Ee(e,t,n,r,i,o){var a,s;if("object"==typeof t){for(s in"string"!=typeof n&&(r=r||n,n=void 0),t)Ee(e,s,n,r,t[s],o);return e}if(null==r&&null==i?(i=n,r=n=void 0):null==i&&("string"==typeof n?(i=r,r=void 0):(i=r,r=n,n=void 0)),!1===i)i=Te;else if(!i)return e;return 1===o&&(a=i,(i=function(e){return S().off(e),a.apply(this,arguments)}).guid=a.guid||(a.guid=S.guid++)),e.each(function(){S.event.add(this,t,i,r,n)})}function Se(e,i,o){o?(Y.set(e,i,!1),S.event.add(e,i,{namespace:!1,handler:function(e){var t,n,r=Y.get(this,i);if(1&e.isTrigger&&this[i]){if(r.length)(S.event.special[i]||{}).delegateType&&e.stopPropagation();else if(r=s.call(arguments),Y.set(this,i,r),t=o(this,i),this[i](),r!==(n=Y.get(this,i))||t?Y.set(this,i,!1):n={},r!==n)return e.stopImmediatePropagation(),e.preventDefault(),n&&n.value}else r.length&&(Y.set(this,i,{value:S.event.trigger(S.extend(r[0],S.Event.prototype),r.slice(1),this)}),e.stopImmediatePropagation())}})):void 0===Y.get(e,i)&&S.event.add(e,i,we)}S.event={global:{},add:function(t,e,n,r,i){var o,a,s,u,l,c,f,p,d,h,g,v=Y.get(t);if(V(t)){n.handler&&(n=(o=n).handler,i=o.selector),i&&S.find.matchesSelector(re,i),n.guid||(n.guid=S.guid++),(u=v.events)||(u=v.events=Object.create(null)),(a=v.handle)||(a=v.handle=function(e){return"undefined"!=typeof S&&S.event.triggered!==e.type?S.event.dispatch.apply(t,arguments):void 0}),l=(e=(e||"").match(P)||[""]).length;while(l--)d=g=(s=be.exec(e[l])||[])[1],h=(s[2]||"").split(".").sort(),d&&(f=S.event.special[d]||{},d=(i?f.delegateType:f.bindType)||d,f=S.event.special[d]||{},c=S.extend({type:d,origType:g,data:r,handler:n,guid:n.guid,selector:i,needsContext:i&&S.expr.match.needsContext.test(i),namespace:h.join(".")},o),(p=u[d])||((p=u[d]=[]).delegateCount=0,f.setup&&!1!==f.setup.call(t,r,h,a)||t.addEventListener&&t.addEventListener(d,a)),f.add&&(f.add.call(t,c),c.handler.guid||(c.handler.guid=n.guid)),i?p.splice(p.delegateCount++,0,c):p.push(c),S.event.global[d]=!0)}},remove:function(e,t,n,r,i){var o,a,s,u,l,c,f,p,d,h,g,v=Y.hasData(e)&&Y.get(e);if(v&&(u=v.events)){l=(t=(t||"").match(P)||[""]).length;while(l--)if(d=g=(s=be.exec(t[l])||[])[1],h=(s[2]||"").split(".").sort(),d){f=S.event.special[d]||{},p=u[d=(r?f.delegateType:f.bindType)||d]||[],s=s[2]&&new RegExp("(^|\\.)"+h.join("\\.(?:.*\\.|)")+"(\\.|$)"),a=o=p.length;while(o--)c=p[o],!i&&g!==c.origType||n&&n.guid!==c.guid||s&&!s.test(c.namespace)||r&&r!==c.selector&&("**"!==r||!c.selector)||(p.splice(o,1),c.selector&&p.delegateCount--,f.remove&&f.remove.call(e,c));a&&!p.length&&(f.teardown&&!1!==f.teardown.call(e,h,v.handle)||S.removeEvent(e,d,v.handle),delete u[d])}else for(d in u)S.event.remove(e,d+t[l],n,r,!0);S.isEmptyObject(u)&&Y.remove(e,"handle events")}},dispatch:function(e){var t,n,r,i,o,a,s=new Array(arguments.length),u=S.event.fix(e),l=(Y.get(this,"events")||Object.create(null))[u.type]||[],c=S.event.special[u.type]||{};for(s[0]=u,t=1;t<arguments.length;t++)s[t]=arguments[t];if(u.delegateTarget=this,!c.preDispatch||!1!==c.preDispatch.call(this,u)){a=S.event.handlers.call(this,u,l),t=0;while((i=a[t++])&&!u.isPropagationStopped()){u.currentTarget=i.elem,n=0;while((o=i.handlers[n++])&&!u.isImmediatePropagationStopped())u.rnamespace&&!1!==o.namespace&&!u.rnamespace.test(o.namespace)||(u.handleObj=o,u.data=o.data,void 0!==(r=((S.event.special[o.origType]||{}).handle||o.handler).apply(i.elem,s))&&!1===(u.result=r)&&(u.preventDefault(),u.stopPropagation()))}return c.postDispatch&&c.postDispatch.call(this,u),u.result}},handlers:function(e,t){var n,r,i,o,a,s=[],u=t.delegateCount,l=e.target;if(u&&l.nodeType&&!("click"===e.type&&1<=e.button))for(;l!==this;l=l.parentNode||this)if(1===l.nodeType&&("click"!==e.type||!0!==l.disabled)){for(o=[],a={},n=0;n<u;n++)void 0===a[i=(r=t[n]).selector+" "]&&(a[i]=r.needsContext?-1<S(i,this).index(l):S.find(i,this,null,[l]).length),a[i]&&o.push(r);o.length&&s.push({elem:l,handlers:o})}return l=this,u<t.length&&s.push({elem:l,handlers:t.slice(u)}),s},addProp:function(t,e){Object.defineProperty(S.Event.prototype,t,{enumerable:!0,configurable:!0,get:m(e)?function(){if(this.originalEvent)return e(this.originalEvent)}:function(){if(this.originalEvent)return this.originalEvent[t]},set:function(e){Object.defineProperty(this,t,{enumerable:!0,configurable:!0,writable:!0,value:e})}})},fix:function(e){return e[S.expando]?e:new S.Event(e)},special:{load:{noBubble:!0},click:{setup:function(e){var t=this||e;return pe.test(t.type)&&t.click&&A(t,"input")&&Se(t,"click",we),!1},trigger:function(e){var t=this||e;return pe.test(t.type)&&t.click&&A(t,"input")&&Se(t,"click"),!0},_default:function(e){var t=e.target;return pe.test(t.type)&&t.click&&A(t,"input")&&Y.get(t,"click")||A(t,"a")}},beforeunload:{postDispatch:function(e){void 0!==e.result&&e.originalEvent&&(e.originalEvent.returnValue=e.result)}}}},S.removeEvent=function(e,t,n){e.removeEventListener&&e.removeEventListener(t,n)},S.Event=function(e,t){if(!(this instanceof S.Event))return new S.Event(e,t);e&&e.type?(this.originalEvent=e,this.type=e.type,this.isDefaultPrevented=e.defaultPrevented||void 0===e.defaultPrevented&&!1===e.returnValue?we:Te,this.target=e.target&&3===e.target.nodeType?e.target.parentNode:e.target,this.currentTarget=e.currentTarget,this.relatedTarget=e.relatedTarget):this.type=e,t&&S.extend(this,t),this.timeStamp=e&&e.timeStamp||Date.now(),this[S.expando]=!0},S.Event.prototype={constructor:S.Event,isDefaultPrevented:Te,isPropagationStopped:Te,isImmediatePropagationStopped:Te,isSimulated:!1,preventDefault:function(){var e=this.originalEvent;this.isDefaultPrevented=we,e&&!this.isSimulated&&e.preventDefault()},stopPropagation:function(){var e=this.originalEvent;this.isPropagationStopped=we,e&&!this.isSimulated&&e.stopPropagation()},stopImmediatePropagation:function(){var e=this.originalEvent;this.isImmediatePropagationStopped=we,e&&!this.isSimulated&&e.stopImmediatePropagation(),this.stopPropagation()}},S.each({altKey:!0,bubbles:!0,cancelable:!0,changedTouches:!0,ctrlKey:!0,detail:!0,eventPhase:!0,metaKey:!0,pageX:!0,pageY:!0,shiftKey:!0,view:!0,"char":!0,code:!0,charCode:!0,key:!0,keyCode:!0,button:!0,buttons:!0,clientX:!0,clientY:!0,offsetX:!0,offsetY:!0,pointerId:!0,pointerType:!0,screenX:!0,screenY:!0,targetTouches:!0,toElement:!0,touches:!0,which:!0},S.event.addProp),S.each({focus:"focusin",blur:"focusout"},function(e,t){S.event.special[e]={setup:function(){return Se(this,e,Ce),!1},trigger:function(){return Se(this,e),!0},_default:function(){return!0},delegateType:t}}),S.each({mouseenter:"mouseover",mouseleave:"mouseout",pointerenter:"pointerover",pointerleave:"pointerout"},function(e,i){S.event.special[e]={delegateType:i,bindType:i,handle:function(e){var t,n=e.relatedTarget,r=e.handleObj;return n&&(n===this||S.contains(this,n))||(e.type=r.origType,t=r.handler.apply(this,arguments),e.type=i),t}}}),S.fn.extend({on:function(e,t,n,r){return Ee(this,e,t,n,r)},one:function(e,t,n,r){return Ee(this,e,t,n,r,1)},off:function(e,t,n){var r,i;if(e&&e.preventDefault&&e.handleObj)return r=e.handleObj,S(e.delegateTarget).off(r.namespace?r.origType+"."+r.namespace:r.origType,r.selector,r.handler),this;if("object"==typeof e){for(i in e)this.off(i,t,e[i]);return this}return!1!==t&&"function"!=typeof t||(n=t,t=void 0),!1===n&&(n=Te),this.each(function(){S.event.remove(this,e,n,t)})}});var ke=/<script|<style|<link/i,Ae=/checked\s*(?:[^=]|=\s*.checked.)/i,Ne=/^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;function je(e,t){return A(e,"table")&&A(11!==t.nodeType?t:t.firstChild,"tr")&&S(e).children("tbody")[0]||e}function De(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function qe(e){return"true/"===(e.type||"").slice(0,5)?e.type=e.type.slice(5):e.removeAttribute("type"),e}function Le(e,t){var n,r,i,o,a,s;if(1===t.nodeType){if(Y.hasData(e)&&(s=Y.get(e).events))for(i in Y.remove(t,"handle events"),s)for(n=0,r=s[i].length;n<r;n++)S.event.add(t,i,s[i][n]);Q.hasData(e)&&(o=Q.access(e),a=S.extend({},o),Q.set(t,a))}}function He(n,r,i,o){r=g(r);var e,t,a,s,u,l,c=0,f=n.length,p=f-1,d=r[0],h=m(d);if(h||1<f&&"string"==typeof d&&!y.checkClone&&Ae.test(d))return n.each(function(e){var t=n.eq(e);h&&(r[0]=d.call(this,e,t.html())),He(t,r,i,o)});if(f&&(t=(e=xe(r,n[0].ownerDocument,!1,n,o)).firstChild,1===e.childNodes.length&&(e=t),t||o)){for(s=(a=S.map(ve(e,"script"),De)).length;c<f;c++)u=e,c!==p&&(u=S.clone(u,!0,!0),s&&S.merge(a,ve(u,"script"))),i.call(n[c],u,c);if(s)for(l=a[a.length-1].ownerDocument,S.map(a,qe),c=0;c<s;c++)u=a[c],he.test(u.type||"")&&!Y.access(u,"globalEval")&&S.contains(l,u)&&(u.src&&"module"!==(u.type||"").toLowerCase()?S._evalUrl&&!u.noModule&&S._evalUrl(u.src,{nonce:u.nonce||u.getAttribute("nonce")},l):b(u.textContent.replace(Ne,""),u,l))}return n}function Oe(e,t,n){for(var r,i=t?S.filter(t,e):e,o=0;null!=(r=i[o]);o++)n||1!==r.nodeType||S.cleanData(ve(r)),r.parentNode&&(n&&ie(r)&&ye(ve(r,"script")),r.parentNode.removeChild(r));return e}S.extend({htmlPrefilter:function(e){return e},clone:function(e,t,n){var r,i,o,a,s,u,l,c=e.cloneNode(!0),f=ie(e);if(!(y.noCloneChecked||1!==e.nodeType&&11!==e.nodeType||S.isXMLDoc(e)))for(a=ve(c),r=0,i=(o=ve(e)).length;r<i;r++)s=o[r],u=a[r],void 0,"input"===(l=u.nodeName.toLowerCase())&&pe.test(s.type)?u.checked=s.checked:"input"!==l&&"textarea"!==l||(u.defaultValue=s.defaultValue);if(t)if(n)for(o=o||ve(e),a=a||ve(c),r=0,i=o.length;r<i;r++)Le(o[r],a[r]);else Le(e,c);return 0<(a=ve(c,"script")).length&&ye(a,!f&&ve(e,"script")),c},cleanData:function(e){for(var t,n,r,i=S.event.special,o=0;void 0!==(n=e[o]);o++)if(V(n)){if(t=n[Y.expando]){if(t.events)for(r in t.events)i[r]?S.event.remove(n,r):S.removeEvent(n,r,t.handle);n[Y.expando]=void 0}n[Q.expando]&&(n[Q.expando]=void 0)}}}),S.fn.extend({detach:function(e){return Oe(this,e,!0)},remove:function(e){return Oe(this,e)},text:function(e){return $(this,function(e){return void 0===e?S.text(this):this.empty().each(function(){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||(this.textContent=e)})},null,e,arguments.length)},append:function(){return He(this,arguments,function(e){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||je(this,e).appendChild(e)})},prepend:function(){return He(this,arguments,function(e){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var t=je(this,e);t.insertBefore(e,t.firstChild)}})},before:function(){return He(this,arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this)})},after:function(){return He(this,arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this.nextSibling)})},empty:function(){for(var e,t=0;null!=(e=this[t]);t++)1===e.nodeType&&(S.cleanData(ve(e,!1)),e.textContent="");return this},clone:function(e,t){return e=null!=e&&e,t=null==t?e:t,this.map(function(){return S.clone(this,e,t)})},html:function(e){return $(this,function(e){var t=this[0]||{},n=0,r=this.length;if(void 0===e&&1===t.nodeType)return t.innerHTML;if("string"==typeof e&&!ke.test(e)&&!ge[(de.exec(e)||["",""])[1].toLowerCase()]){e=S.htmlPrefilter(e);try{for(;n<r;n++)1===(t=this[n]||{}).nodeType&&(S.cleanData(ve(t,!1)),t.innerHTML=e);t=0}catch(e){}}t&&this.empty().append(e)},null,e,arguments.length)},replaceWith:function(){var n=[];return He(this,arguments,function(e){var t=this.parentNode;S.inArray(this,n)<0&&(S.cleanData(ve(this)),t&&t.replaceChild(e,this))},n)}}),S.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(e,a){S.fn[e]=function(e){for(var t,n=[],r=S(e),i=r.length-1,o=0;o<=i;o++)t=o===i?this:this.clone(!0),S(r[o])[a](t),u.apply(n,t.get());return this.pushStack(n)}});var Pe=new RegExp("^("+ee+")(?!px)[a-z%]+$","i"),Re=function(e){var t=e.ownerDocument.defaultView;return t&&t.opener||(t=C),t.getComputedStyle(e)},Me=function(e,t,n){var r,i,o={};for(i in t)o[i]=e.style[i],e.style[i]=t[i];for(i in r=n.call(e),t)e.style[i]=o[i];return r},Ie=new RegExp(ne.join("|"),"i");function We(e,t,n){var r,i,o,a,s=e.style;return(n=n||Re(e))&&(""!==(a=n.getPropertyValue(t)||n[t])||ie(e)||(a=S.style(e,t)),!y.pixelBoxStyles()&&Pe.test(a)&&Ie.test(t)&&(r=s.width,i=s.minWidth,o=s.maxWidth,s.minWidth=s.maxWidth=s.width=a,a=n.width,s.width=r,s.minWidth=i,s.maxWidth=o)),void 0!==a?a+"":a}function Fe(e,t){return{get:function(){if(!e())return(this.get=t).apply(this,arguments);delete this.get}}}!function(){function e(){if(l){u.style.cssText="position:absolute;left:-11111px;width:60px;margin-top:1px;padding:0;border:0",l.style.cssText="position:relative;display:block;box-sizing:border-box;overflow:scroll;margin:auto;border:1px;padding:1px;width:60%;top:1%",re.appendChild(u).appendChild(l);var e=C.getComputedStyle(l);n="1%"!==e.top,s=12===t(e.marginLeft),l.style.right="60%",o=36===t(e.right),r=36===t(e.width),l.style.position="absolute",i=12===t(l.offsetWidth/3),re.removeChild(u),l=null}}function t(e){return Math.round(parseFloat(e))}var n,r,i,o,a,s,u=E.createElement("div"),l=E.createElement("div");l.style&&(l.style.backgroundClip="content-box",l.cloneNode(!0).style.backgroundClip="",y.clearCloneStyle="content-box"===l.style.backgroundClip,S.extend(y,{boxSizingReliable:function(){return e(),r},pixelBoxStyles:function(){return e(),o},pixelPosition:function(){return e(),n},reliableMarginLeft:function(){return e(),s},scrollboxSize:function(){return e(),i},reliableTrDimensions:function(){var e,t,n,r;return null==a&&(e=E.createElement("table"),t=E.createElement("tr"),n=E.createElement("div"),e.style.cssText="position:absolute;left:-11111px;border-collapse:separate",t.style.cssText="border:1px solid",t.style.height="1px",n.style.height="9px",n.style.display="block",re.appendChild(e).appendChild(t).appendChild(n),r=C.getComputedStyle(t),a=parseInt(r.height,10)+parseInt(r.borderTopWidth,10)+parseInt(r.borderBottomWidth,10)===t.offsetHeight,re.removeChild(e)),a}}))}();var Be=["Webkit","Moz","ms"],$e=E.createElement("div").style,_e={};function ze(e){var t=S.cssProps[e]||_e[e];return t||(e in $e?e:_e[e]=function(e){var t=e[0].toUpperCase()+e.slice(1),n=Be.length;while(n--)if((e=Be[n]+t)in $e)return e}(e)||e)}var Ue=/^(none|table(?!-c[ea]).+)/,Xe=/^--/,Ve={position:"absolute",visibility:"hidden",display:"block"},Ge={letterSpacing:"0",fontWeight:"400"};function Ye(e,t,n){var r=te.exec(t);return r?Math.max(0,r[2]-(n||0))+(r[3]||"px"):t}function Qe(e,t,n,r,i,o){var a="width"===t?1:0,s=0,u=0;if(n===(r?"border":"content"))return 0;for(;a<4;a+=2)"margin"===n&&(u+=S.css(e,n+ne[a],!0,i)),r?("content"===n&&(u-=S.css(e,"padding"+ne[a],!0,i)),"margin"!==n&&(u-=S.css(e,"border"+ne[a]+"Width",!0,i))):(u+=S.css(e,"padding"+ne[a],!0,i),"padding"!==n?u+=S.css(e,"border"+ne[a]+"Width",!0,i):s+=S.css(e,"border"+ne[a]+"Width",!0,i));return!r&&0<=o&&(u+=Math.max(0,Math.ceil(e["offset"+t[0].toUpperCase()+t.slice(1)]-o-u-s-.5))||0),u}function Je(e,t,n){var r=Re(e),i=(!y.boxSizingReliable()||n)&&"border-box"===S.css(e,"boxSizing",!1,r),o=i,a=We(e,t,r),s="offset"+t[0].toUpperCase()+t.slice(1);if(Pe.test(a)){if(!n)return a;a="auto"}return(!y.boxSizingReliable()&&i||!y.reliableTrDimensions()&&A(e,"tr")||"auto"===a||!parseFloat(a)&&"inline"===S.css(e,"display",!1,r))&&e.getClientRects().length&&(i="border-box"===S.css(e,"boxSizing",!1,r),(o=s in e)&&(a=e[s])),(a=parseFloat(a)||0)+Qe(e,t,n||(i?"border":"content"),o,r,a)+"px"}function Ke(e,t,n,r,i){return new Ke.prototype.init(e,t,n,r,i)}S.extend({cssHooks:{opacity:{get:function(e,t){if(t){var n=We(e,"opacity");return""===n?"1":n}}}},cssNumber:{animationIterationCount:!0,columnCount:!0,fillOpacity:!0,flexGrow:!0,flexShrink:!0,fontWeight:!0,gridArea:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnStart:!0,gridRow:!0,gridRowEnd:!0,gridRowStart:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{},style:function(e,t,n,r){if(e&&3!==e.nodeType&&8!==e.nodeType&&e.style){var i,o,a,s=X(t),u=Xe.test(t),l=e.style;if(u||(t=ze(s)),a=S.cssHooks[t]||S.cssHooks[s],void 0===n)return a&&"get"in a&&void 0!==(i=a.get(e,!1,r))?i:l[t];"string"===(o=typeof n)&&(i=te.exec(n))&&i[1]&&(n=se(e,t,i),o="number"),null!=n&&n==n&&("number"!==o||u||(n+=i&&i[3]||(S.cssNumber[s]?"":"px")),y.clearCloneStyle||""!==n||0!==t.indexOf("background")||(l[t]="inherit"),a&&"set"in a&&void 0===(n=a.set(e,n,r))||(u?l.setProperty(t,n):l[t]=n))}},css:function(e,t,n,r){var i,o,a,s=X(t);return Xe.test(t)||(t=ze(s)),(a=S.cssHooks[t]||S.cssHooks[s])&&"get"in a&&(i=a.get(e,!0,n)),void 0===i&&(i=We(e,t,r)),"normal"===i&&t in Ge&&(i=Ge[t]),""===n||n?(o=parseFloat(i),!0===n||isFinite(o)?o||0:i):i}}),S.each(["height","width"],function(e,u){S.cssHooks[u]={get:function(e,t,n){if(t)return!Ue.test(S.css(e,"display"))||e.getClientRects().length&&e.getBoundingClientRect().width?Je(e,u,n):Me(e,Ve,function(){return Je(e,u,n)})},set:function(e,t,n){var r,i=Re(e),o=!y.scrollboxSize()&&"absolute"===i.position,a=(o||n)&&"border-box"===S.css(e,"boxSizing",!1,i),s=n?Qe(e,u,n,a,i):0;return a&&o&&(s-=Math.ceil(e["offset"+u[0].toUpperCase()+u.slice(1)]-parseFloat(i[u])-Qe(e,u,"border",!1,i)-.5)),s&&(r=te.exec(t))&&"px"!==(r[3]||"px")&&(e.style[u]=t,t=S.css(e,u)),Ye(0,t,s)}}}),S.cssHooks.marginLeft=Fe(y.reliableMarginLeft,function(e,t){if(t)return(parseFloat(We(e,"marginLeft"))||e.getBoundingClientRect().left-Me(e,{marginLeft:0},function(){return e.getBoundingClientRect().left}))+"px"}),S.each({margin:"",padding:"",border:"Width"},function(i,o){S.cssHooks[i+o]={expand:function(e){for(var t=0,n={},r="string"==typeof e?e.split(" "):[e];t<4;t++)n[i+ne[t]+o]=r[t]||r[t-2]||r[0];return n}},"margin"!==i&&(S.cssHooks[i+o].set=Ye)}),S.fn.extend({css:function(e,t){return $(this,function(e,t,n){var r,i,o={},a=0;if(Array.isArray(t)){for(r=Re(e),i=t.length;a<i;a++)o[t[a]]=S.css(e,t[a],!1,r);return o}return void 0!==n?S.style(e,t,n):S.css(e,t)},e,t,1<arguments.length)}}),((S.Tween=Ke).prototype={constructor:Ke,init:function(e,t,n,r,i,o){this.elem=e,this.prop=n,this.easing=i||S.easing._default,this.options=t,this.start=this.now=this.cur(),this.end=r,this.unit=o||(S.cssNumber[n]?"":"px")},cur:function(){var e=Ke.propHooks[this.prop];return e&&e.get?e.get(this):Ke.propHooks._default.get(this)},run:function(e){var t,n=Ke.propHooks[this.prop];return this.options.duration?this.pos=t=S.easing[this.easing](e,this.options.duration*e,0,1,this.options.duration):this.pos=t=e,this.now=(this.end-this.start)*t+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),n&&n.set?n.set(this):Ke.propHooks._default.set(this),this}}).init.prototype=Ke.prototype,(Ke.propHooks={_default:{get:function(e){var t;return 1!==e.elem.nodeType||null!=e.elem[e.prop]&&null==e.elem.style[e.prop]?e.elem[e.prop]:(t=S.css(e.elem,e.prop,""))&&"auto"!==t?t:0},set:function(e){S.fx.step[e.prop]?S.fx.step[e.prop](e):1!==e.elem.nodeType||!S.cssHooks[e.prop]&&null==e.elem.style[ze(e.prop)]?e.elem[e.prop]=e.now:S.style(e.elem,e.prop,e.now+e.unit)}}}).scrollTop=Ke.propHooks.scrollLeft={set:function(e){e.elem.nodeType&&e.elem.parentNode&&(e.elem[e.prop]=e.now)}},S.easing={linear:function(e){return e},swing:function(e){return.5-Math.cos(e*Math.PI)/2},_default:"swing"},S.fx=Ke.prototype.init,S.fx.step={};var Ze,et,tt,nt,rt=/^(?:toggle|show|hide)$/,it=/queueHooks$/;function ot(){et&&(!1===E.hidden&&C.requestAnimationFrame?C.requestAnimationFrame(ot):C.setTimeout(ot,S.fx.interval),S.fx.tick())}function at(){return C.setTimeout(function(){Ze=void 0}),Ze=Date.now()}function st(e,t){var n,r=0,i={height:e};for(t=t?1:0;r<4;r+=2-t)i["margin"+(n=ne[r])]=i["padding"+n]=e;return t&&(i.opacity=i.width=e),i}function ut(e,t,n){for(var r,i=(lt.tweeners[t]||[]).concat(lt.tweeners["*"]),o=0,a=i.length;o<a;o++)if(r=i[o].call(n,t,e))return r}function lt(o,e,t){var n,a,r=0,i=lt.prefilters.length,s=S.Deferred().always(function(){delete u.elem}),u=function(){if(a)return!1;for(var e=Ze||at(),t=Math.max(0,l.startTime+l.duration-e),n=1-(t/l.duration||0),r=0,i=l.tweens.length;r<i;r++)l.tweens[r].run(n);return s.notifyWith(o,[l,n,t]),n<1&&i?t:(i||s.notifyWith(o,[l,1,0]),s.resolveWith(o,[l]),!1)},l=s.promise({elem:o,props:S.extend({},e),opts:S.extend(!0,{specialEasing:{},easing:S.easing._default},t),originalProperties:e,originalOptions:t,startTime:Ze||at(),duration:t.duration,tweens:[],createTween:function(e,t){var n=S.Tween(o,l.opts,e,t,l.opts.specialEasing[e]||l.opts.easing);return l.tweens.push(n),n},stop:function(e){var t=0,n=e?l.tweens.length:0;if(a)return this;for(a=!0;t<n;t++)l.tweens[t].run(1);return e?(s.notifyWith(o,[l,1,0]),s.resolveWith(o,[l,e])):s.rejectWith(o,[l,e]),this}}),c=l.props;for(!function(e,t){var n,r,i,o,a;for(n in e)if(i=t[r=X(n)],o=e[n],Array.isArray(o)&&(i=o[1],o=e[n]=o[0]),n!==r&&(e[r]=o,delete e[n]),(a=S.cssHooks[r])&&"expand"in a)for(n in o=a.expand(o),delete e[r],o)n in e||(e[n]=o[n],t[n]=i);else t[r]=i}(c,l.opts.specialEasing);r<i;r++)if(n=lt.prefilters[r].call(l,o,c,l.opts))return m(n.stop)&&(S._queueHooks(l.elem,l.opts.queue).stop=n.stop.bind(n)),n;return S.map(c,ut,l),m(l.opts.start)&&l.opts.start.call(o,l),l.progress(l.opts.progress).done(l.opts.done,l.opts.complete).fail(l.opts.fail).always(l.opts.always),S.fx.timer(S.extend(u,{elem:o,anim:l,queue:l.opts.queue})),l}S.Animation=S.extend(lt,{tweeners:{"*":[function(e,t){var n=this.createTween(e,t);return se(n.elem,e,te.exec(t),n),n}]},tweener:function(e,t){m(e)?(t=e,e=["*"]):e=e.match(P);for(var n,r=0,i=e.length;r<i;r++)n=e[r],lt.tweeners[n]=lt.tweeners[n]||[],lt.tweeners[n].unshift(t)},prefilters:[function(e,t,n){var r,i,o,a,s,u,l,c,f="width"in t||"height"in t,p=this,d={},h=e.style,g=e.nodeType&&ae(e),v=Y.get(e,"fxshow");for(r in n.queue||(null==(a=S._queueHooks(e,"fx")).unqueued&&(a.unqueued=0,s=a.empty.fire,a.empty.fire=function(){a.unqueued||s()}),a.unqueued++,p.always(function(){p.always(function(){a.unqueued--,S.queue(e,"fx").length||a.empty.fire()})})),t)if(i=t[r],rt.test(i)){if(delete t[r],o=o||"toggle"===i,i===(g?"hide":"show")){if("show"!==i||!v||void 0===v[r])continue;g=!0}d[r]=v&&v[r]||S.style(e,r)}if((u=!S.isEmptyObject(t))||!S.isEmptyObject(d))for(r in f&&1===e.nodeType&&(n.overflow=[h.overflow,h.overflowX,h.overflowY],null==(l=v&&v.display)&&(l=Y.get(e,"display")),"none"===(c=S.css(e,"display"))&&(l?c=l:(le([e],!0),l=e.style.display||l,c=S.css(e,"display"),le([e]))),("inline"===c||"inline-block"===c&&null!=l)&&"none"===S.css(e,"float")&&(u||(p.done(function(){h.display=l}),null==l&&(c=h.display,l="none"===c?"":c)),h.display="inline-block")),n.overflow&&(h.overflow="hidden",p.always(function(){h.overflow=n.overflow[0],h.overflowX=n.overflow[1],h.overflowY=n.overflow[2]})),u=!1,d)u||(v?"hidden"in v&&(g=v.hidden):v=Y.access(e,"fxshow",{display:l}),o&&(v.hidden=!g),g&&le([e],!0),p.done(function(){for(r in g||le([e]),Y.remove(e,"fxshow"),d)S.style(e,r,d[r])})),u=ut(g?v[r]:0,r,p),r in v||(v[r]=u.start,g&&(u.end=u.start,u.start=0))}],prefilter:function(e,t){t?lt.prefilters.unshift(e):lt.prefilters.push(e)}}),S.speed=function(e,t,n){var r=e&&"object"==typeof e?S.extend({},e):{complete:n||!n&&t||m(e)&&e,duration:e,easing:n&&t||t&&!m(t)&&t};return S.fx.off?r.duration=0:"number"!=typeof r.duration&&(r.duration in S.fx.speeds?r.duration=S.fx.speeds[r.duration]:r.duration=S.fx.speeds._default),null!=r.queue&&!0!==r.queue||(r.queue="fx"),r.old=r.complete,r.complete=function(){m(r.old)&&r.old.call(this),r.queue&&S.dequeue(this,r.queue)},r},S.fn.extend({fadeTo:function(e,t,n,r){return this.filter(ae).css("opacity",0).show().end().animate({opacity:t},e,n,r)},animate:function(t,e,n,r){var i=S.isEmptyObject(t),o=S.speed(e,n,r),a=function(){var e=lt(this,S.extend({},t),o);(i||Y.get(this,"finish"))&&e.stop(!0)};return a.finish=a,i||!1===o.queue?this.each(a):this.queue(o.queue,a)},stop:function(i,e,o){var a=function(e){var t=e.stop;delete e.stop,t(o)};return"string"!=typeof i&&(o=e,e=i,i=void 0),e&&this.queue(i||"fx",[]),this.each(function(){var e=!0,t=null!=i&&i+"queueHooks",n=S.timers,r=Y.get(this);if(t)r[t]&&r[t].stop&&a(r[t]);else for(t in r)r[t]&&r[t].stop&&it.test(t)&&a(r[t]);for(t=n.length;t--;)n[t].elem!==this||null!=i&&n[t].queue!==i||(n[t].anim.stop(o),e=!1,n.splice(t,1));!e&&o||S.dequeue(this,i)})},finish:function(a){return!1!==a&&(a=a||"fx"),this.each(function(){var e,t=Y.get(this),n=t[a+"queue"],r=t[a+"queueHooks"],i=S.timers,o=n?n.length:0;for(t.finish=!0,S.queue(this,a,[]),r&&r.stop&&r.stop.call(this,!0),e=i.length;e--;)i[e].elem===this&&i[e].queue===a&&(i[e].anim.stop(!0),i.splice(e,1));for(e=0;e<o;e++)n[e]&&n[e].finish&&n[e].finish.call(this);delete t.finish})}}),S.each(["toggle","show","hide"],function(e,r){var i=S.fn[r];S.fn[r]=function(e,t,n){return null==e||"boolean"==typeof e?i.apply(this,arguments):this.animate(st(r,!0),e,t,n)}}),S.each({slideDown:st("show"),slideUp:st("hide"),slideToggle:st("toggle"),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},function(e,r){S.fn[e]=function(e,t,n){return this.animate(r,e,t,n)}}),S.timers=[],S.fx.tick=function(){var e,t=0,n=S.timers;for(Ze=Date.now();t<n.length;t++)(e=n[t])()||n[t]!==e||n.splice(t--,1);n.length||S.fx.stop(),Ze=void 0},S.fx.timer=function(e){S.timers.push(e),S.fx.start()},S.fx.interval=13,S.fx.start=function(){et||(et=!0,ot())},S.fx.stop=function(){et=null},S.fx.speeds={slow:600,fast:200,_default:400},S.fn.delay=function(r,e){return r=S.fx&&S.fx.speeds[r]||r,e=e||"fx",this.queue(e,function(e,t){var n=C.setTimeout(e,r);t.stop=function(){C.clearTimeout(n)}})},tt=E.createElement("input"),nt=E.createElement("select").appendChild(E.createElement("option")),tt.type="checkbox",y.checkOn=""!==tt.value,y.optSelected=nt.selected,(tt=E.createElement("input")).value="t",tt.type="radio",y.radioValue="t"===tt.value;var ct,ft=S.expr.attrHandle;S.fn.extend({attr:function(e,t){return $(this,S.attr,e,t,1<arguments.length)},removeAttr:function(e){return this.each(function(){S.removeAttr(this,e)})}}),S.extend({attr:function(e,t,n){var r,i,o=e.nodeType;if(3!==o&&8!==o&&2!==o)return"undefined"==typeof e.getAttribute?S.prop(e,t,n):(1===o&&S.isXMLDoc(e)||(i=S.attrHooks[t.toLowerCase()]||(S.expr.match.bool.test(t)?ct:void 0)),void 0!==n?null===n?void S.removeAttr(e,t):i&&"set"in i&&void 0!==(r=i.set(e,n,t))?r:(e.setAttribute(t,n+""),n):i&&"get"in i&&null!==(r=i.get(e,t))?r:null==(r=S.find.attr(e,t))?void 0:r)},attrHooks:{type:{set:function(e,t){if(!y.radioValue&&"radio"===t&&A(e,"input")){var n=e.value;return e.setAttribute("type",t),n&&(e.value=n),t}}}},removeAttr:function(e,t){var n,r=0,i=t&&t.match(P);if(i&&1===e.nodeType)while(n=i[r++])e.removeAttribute(n)}}),ct={set:function(e,t,n){return!1===t?S.removeAttr(e,n):e.setAttribute(n,n),n}},S.each(S.expr.match.bool.source.match(/\w+/g),function(e,t){var a=ft[t]||S.find.attr;ft[t]=function(e,t,n){var r,i,o=t.toLowerCase();return n||(i=ft[o],ft[o]=r,r=null!=a(e,t,n)?o:null,ft[o]=i),r}});var pt=/^(?:input|select|textarea|button)$/i,dt=/^(?:a|area)$/i;function ht(e){return(e.match(P)||[]).join(" ")}function gt(e){return e.getAttribute&&e.getAttribute("class")||""}function vt(e){return Array.isArray(e)?e:"string"==typeof e&&e.match(P)||[]}S.fn.extend({prop:function(e,t){return $(this,S.prop,e,t,1<arguments.length)},removeProp:function(e){return this.each(function(){delete this[S.propFix[e]||e]})}}),S.extend({prop:function(e,t,n){var r,i,o=e.nodeType;if(3!==o&&8!==o&&2!==o)return 1===o&&S.isXMLDoc(e)||(t=S.propFix[t]||t,i=S.propHooks[t]),void 0!==n?i&&"set"in i&&void 0!==(r=i.set(e,n,t))?r:e[t]=n:i&&"get"in i&&null!==(r=i.get(e,t))?r:e[t]},propHooks:{tabIndex:{get:function(e){var t=S.find.attr(e,"tabindex");return t?parseInt(t,10):pt.test(e.nodeName)||dt.test(e.nodeName)&&e.href?0:-1}}},propFix:{"for":"htmlFor","class":"className"}}),y.optSelected||(S.propHooks.selected={get:function(e){var t=e.parentNode;return t&&t.parentNode&&t.parentNode.selectedIndex,null},set:function(e){var t=e.parentNode;t&&(t.selectedIndex,t.parentNode&&t.parentNode.selectedIndex)}}),S.each(["tabIndex","readOnly","maxLength","cellSpacing","cellPadding","rowSpan","colSpan","useMap","frameBorder","contentEditable"],function(){S.propFix[this.toLowerCase()]=this}),S.fn.extend({addClass:function(t){var e,n,r,i,o,a,s,u=0;if(m(t))return this.each(function(e){S(this).addClass(t.call(this,e,gt(this)))});if((e=vt(t)).length)while(n=this[u++])if(i=gt(n),r=1===n.nodeType&&" "+ht(i)+" "){a=0;while(o=e[a++])r.indexOf(" "+o+" ")<0&&(r+=o+" ");i!==(s=ht(r))&&n.setAttribute("class",s)}return this},removeClass:function(t){var e,n,r,i,o,a,s,u=0;if(m(t))return this.each(function(e){S(this).removeClass(t.call(this,e,gt(this)))});if(!arguments.length)return this.attr("class","");if((e=vt(t)).length)while(n=this[u++])if(i=gt(n),r=1===n.nodeType&&" "+ht(i)+" "){a=0;while(o=e[a++])while(-1<r.indexOf(" "+o+" "))r=r.replace(" "+o+" "," ");i!==(s=ht(r))&&n.setAttribute("class",s)}return this},toggleClass:function(i,t){var o=typeof i,a="string"===o||Array.isArray(i);return"boolean"==typeof t&&a?t?this.addClass(i):this.removeClass(i):m(i)?this.each(function(e){S(this).toggleClass(i.call(this,e,gt(this),t),t)}):this.each(function(){var e,t,n,r;if(a){t=0,n=S(this),r=vt(i);while(e=r[t++])n.hasClass(e)?n.removeClass(e):n.addClass(e)}else void 0!==i&&"boolean"!==o||((e=gt(this))&&Y.set(this,"__className__",e),this.setAttribute&&this.setAttribute("class",e||!1===i?"":Y.get(this,"__className__")||""))})},hasClass:function(e){var t,n,r=0;t=" "+e+" ";while(n=this[r++])if(1===n.nodeType&&-1<(" "+ht(gt(n))+" ").indexOf(t))return!0;return!1}});var yt=/\r/g;S.fn.extend({val:function(n){var r,e,i,t=this[0];return arguments.length?(i=m(n),this.each(function(e){var t;1===this.nodeType&&(null==(t=i?n.call(this,e,S(this).val()):n)?t="":"number"==typeof t?t+="":Array.isArray(t)&&(t=S.map(t,function(e){return null==e?"":e+""})),(r=S.valHooks[this.type]||S.valHooks[this.nodeName.toLowerCase()])&&"set"in r&&void 0!==r.set(this,t,"value")||(this.value=t))})):t?(r=S.valHooks[t.type]||S.valHooks[t.nodeName.toLowerCase()])&&"get"in r&&void 0!==(e=r.get(t,"value"))?e:"string"==typeof(e=t.value)?e.replace(yt,""):null==e?"":e:void 0}}),S.extend({valHooks:{option:{get:function(e){var t=S.find.attr(e,"value");return null!=t?t:ht(S.text(e))}},select:{get:function(e){var t,n,r,i=e.options,o=e.selectedIndex,a="select-one"===e.type,s=a?null:[],u=a?o+1:i.length;for(r=o<0?u:a?o:0;r<u;r++)if(((n=i[r]).selected||r===o)&&!n.disabled&&(!n.parentNode.disabled||!A(n.parentNode,"optgroup"))){if(t=S(n).val(),a)return t;s.push(t)}return s},set:function(e,t){var n,r,i=e.options,o=S.makeArray(t),a=i.length;while(a--)((r=i[a]).selected=-1<S.inArray(S.valHooks.option.get(r),o))&&(n=!0);return n||(e.selectedIndex=-1),o}}}}),S.each(["radio","checkbox"],function(){S.valHooks[this]={set:function(e,t){if(Array.isArray(t))return e.checked=-1<S.inArray(S(e).val(),t)}},y.checkOn||(S.valHooks[this].get=function(e){return null===e.getAttribute("value")?"on":e.value})}),y.focusin="onfocusin"in C;var mt=/^(?:focusinfocus|focusoutblur)$/,xt=function(e){e.stopPropagation()};S.extend(S.event,{trigger:function(e,t,n,r){var i,o,a,s,u,l,c,f,p=[n||E],d=v.call(e,"type")?e.type:e,h=v.call(e,"namespace")?e.namespace.split("."):[];if(o=f=a=n=n||E,3!==n.nodeType&&8!==n.nodeType&&!mt.test(d+S.event.triggered)&&(-1<d.indexOf(".")&&(d=(h=d.split(".")).shift(),h.sort()),u=d.indexOf(":")<0&&"on"+d,(e=e[S.expando]?e:new S.Event(d,"object"==typeof e&&e)).isTrigger=r?2:3,e.namespace=h.join("."),e.rnamespace=e.namespace?new RegExp("(^|\\.)"+h.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,e.result=void 0,e.target||(e.target=n),t=null==t?[e]:S.makeArray(t,[e]),c=S.event.special[d]||{},r||!c.trigger||!1!==c.trigger.apply(n,t))){if(!r&&!c.noBubble&&!x(n)){for(s=c.delegateType||d,mt.test(s+d)||(o=o.parentNode);o;o=o.parentNode)p.push(o),a=o;a===(n.ownerDocument||E)&&p.push(a.defaultView||a.parentWindow||C)}i=0;while((o=p[i++])&&!e.isPropagationStopped())f=o,e.type=1<i?s:c.bindType||d,(l=(Y.get(o,"events")||Object.create(null))[e.type]&&Y.get(o,"handle"))&&l.apply(o,t),(l=u&&o[u])&&l.apply&&V(o)&&(e.result=l.apply(o,t),!1===e.result&&e.preventDefault());return e.type=d,r||e.isDefaultPrevented()||c._default&&!1!==c._default.apply(p.pop(),t)||!V(n)||u&&m(n[d])&&!x(n)&&((a=n[u])&&(n[u]=null),S.event.triggered=d,e.isPropagationStopped()&&f.addEventListener(d,xt),n[d](),e.isPropagationStopped()&&f.removeEventListener(d,xt),S.event.triggered=void 0,a&&(n[u]=a)),e.result}},simulate:function(e,t,n){var r=S.extend(new S.Event,n,{type:e,isSimulated:!0});S.event.trigger(r,null,t)}}),S.fn.extend({trigger:function(e,t){return this.each(function(){S.event.trigger(e,t,this)})},triggerHandler:function(e,t){var n=this[0];if(n)return S.event.trigger(e,t,n,!0)}}),y.focusin||S.each({focus:"focusin",blur:"focusout"},function(n,r){var i=function(e){S.event.simulate(r,e.target,S.event.fix(e))};S.event.special[r]={setup:function(){var e=this.ownerDocument||this.document||this,t=Y.access(e,r);t||e.addEventListener(n,i,!0),Y.access(e,r,(t||0)+1)},teardown:function(){var e=this.ownerDocument||this.document||this,t=Y.access(e,r)-1;t?Y.access(e,r,t):(e.removeEventListener(n,i,!0),Y.remove(e,r))}}});var bt=C.location,wt={guid:Date.now()},Tt=/\?/;S.parseXML=function(e){var t,n;if(!e||"string"!=typeof e)return null;try{t=(new C.DOMParser).parseFromString(e,"text/xml")}catch(e){}return n=t&&t.getElementsByTagName("parsererror")[0],t&&!n||S.error("Invalid XML: "+(n?S.map(n.childNodes,function(e){return e.textContent}).join("\n"):e)),t};var Ct=/\[\]$/,Et=/\r?\n/g,St=/^(?:submit|button|image|reset|file)$/i,kt=/^(?:input|select|textarea|keygen)/i;function At(n,e,r,i){var t;if(Array.isArray(e))S.each(e,function(e,t){r||Ct.test(n)?i(n,t):At(n+"["+("object"==typeof t&&null!=t?e:"")+"]",t,r,i)});else if(r||"object"!==w(e))i(n,e);else for(t in e)At(n+"["+t+"]",e[t],r,i)}S.param=function(e,t){var n,r=[],i=function(e,t){var n=m(t)?t():t;r[r.length]=encodeURIComponent(e)+"="+encodeURIComponent(null==n?"":n)};if(null==e)return"";if(Array.isArray(e)||e.jquery&&!S.isPlainObject(e))S.each(e,function(){i(this.name,this.value)});else for(n in e)At(n,e[n],t,i);return r.join("&")},S.fn.extend({serialize:function(){return S.param(this.serializeArray())},serializeArray:function(){return this.map(function(){var e=S.prop(this,"elements");return e?S.makeArray(e):this}).filter(function(){var e=this.type;return this.name&&!S(this).is(":disabled")&&kt.test(this.nodeName)&&!St.test(e)&&(this.checked||!pe.test(e))}).map(function(e,t){var n=S(this).val();return null==n?null:Array.isArray(n)?S.map(n,function(e){return{name:t.name,value:e.replace(Et,"\r\n")}}):{name:t.name,value:n.replace(Et,"\r\n")}}).get()}});var Nt=/%20/g,jt=/#.*$/,Dt=/([?&])_=[^&]*/,qt=/^(.*?):[ \t]*([^\r\n]*)$/gm,Lt=/^(?:GET|HEAD)$/,Ht=/^\/\//,Ot={},Pt={},Rt="*/".concat("*"),Mt=E.createElement("a");function It(o){return function(e,t){"string"!=typeof e&&(t=e,e="*");var n,r=0,i=e.toLowerCase().match(P)||[];if(m(t))while(n=i[r++])"+"===n[0]?(n=n.slice(1)||"*",(o[n]=o[n]||[]).unshift(t)):(o[n]=o[n]||[]).push(t)}}function Wt(t,i,o,a){var s={},u=t===Pt;function l(e){var r;return s[e]=!0,S.each(t[e]||[],function(e,t){var n=t(i,o,a);return"string"!=typeof n||u||s[n]?u?!(r=n):void 0:(i.dataTypes.unshift(n),l(n),!1)}),r}return l(i.dataTypes[0])||!s["*"]&&l("*")}function Ft(e,t){var n,r,i=S.ajaxSettings.flatOptions||{};for(n in t)void 0!==t[n]&&((i[n]?e:r||(r={}))[n]=t[n]);return r&&S.extend(!0,e,r),e}Mt.href=bt.href,S.extend({active:0,lastModified:{},etag:{},ajaxSettings:{url:bt.href,type:"GET",isLocal:/^(?:about|app|app-storage|.+-extension|file|res|widget):$/.test(bt.protocol),global:!0,processData:!0,async:!0,contentType:"application/x-www-form-urlencoded; charset=UTF-8",accepts:{"*":Rt,text:"text/plain",html:"text/html",xml:"application/xml, text/xml",json:"application/json, text/javascript"},contents:{xml:/\bxml\b/,html:/\bhtml/,json:/\bjson\b/},responseFields:{xml:"responseXML",text:"responseText",json:"responseJSON"},converters:{"* text":String,"text html":!0,"text json":JSON.parse,"text xml":S.parseXML},flatOptions:{url:!0,context:!0}},ajaxSetup:function(e,t){return t?Ft(Ft(e,S.ajaxSettings),t):Ft(S.ajaxSettings,e)},ajaxPrefilter:It(Ot),ajaxTransport:It(Pt),ajax:function(e,t){"object"==typeof e&&(t=e,e=void 0),t=t||{};var c,f,p,n,d,r,h,g,i,o,v=S.ajaxSetup({},t),y=v.context||v,m=v.context&&(y.nodeType||y.jquery)?S(y):S.event,x=S.Deferred(),b=S.Callbacks("once memory"),w=v.statusCode||{},a={},s={},u="canceled",T={readyState:0,getResponseHeader:function(e){var t;if(h){if(!n){n={};while(t=qt.exec(p))n[t[1].toLowerCase()+" "]=(n[t[1].toLowerCase()+" "]||[]).concat(t[2])}t=n[e.toLowerCase()+" "]}return null==t?null:t.join(", ")},getAllResponseHeaders:function(){return h?p:null},setRequestHeader:function(e,t){return null==h&&(e=s[e.toLowerCase()]=s[e.toLowerCase()]||e,a[e]=t),this},overrideMimeType:function(e){return null==h&&(v.mimeType=e),this},statusCode:function(e){var t;if(e)if(h)T.always(e[T.status]);else for(t in e)w[t]=[w[t],e[t]];return this},abort:function(e){var t=e||u;return c&&c.abort(t),l(0,t),this}};if(x.promise(T),v.url=((e||v.url||bt.href)+"").replace(Ht,bt.protocol+"//"),v.type=t.method||t.type||v.method||v.type,v.dataTypes=(v.dataType||"*").toLowerCase().match(P)||[""],null==v.crossDomain){r=E.createElement("a");try{r.href=v.url,r.href=r.href,v.crossDomain=Mt.protocol+"//"+Mt.host!=r.protocol+"//"+r.host}catch(e){v.crossDomain=!0}}if(v.data&&v.processData&&"string"!=typeof v.data&&(v.data=S.param(v.data,v.traditional)),Wt(Ot,v,t,T),h)return T;for(i in(g=S.event&&v.global)&&0==S.active++&&S.event.trigger("ajaxStart"),v.type=v.type.toUpperCase(),v.hasContent=!Lt.test(v.type),f=v.url.replace(jt,""),v.hasContent?v.data&&v.processData&&0===(v.contentType||"").indexOf("application/x-www-form-urlencoded")&&(v.data=v.data.replace(Nt,"+")):(o=v.url.slice(f.length),v.data&&(v.processData||"string"==typeof v.data)&&(f+=(Tt.test(f)?"&":"?")+v.data,delete v.data),!1===v.cache&&(f=f.replace(Dt,"$1"),o=(Tt.test(f)?"&":"?")+"_="+wt.guid+++o),v.url=f+o),v.ifModified&&(S.lastModified[f]&&T.setRequestHeader("If-Modified-Since",S.lastModified[f]),S.etag[f]&&T.setRequestHeader("If-None-Match",S.etag[f])),(v.data&&v.hasContent&&!1!==v.contentType||t.contentType)&&T.setRequestHeader("Content-Type",v.contentType),T.setRequestHeader("Accept",v.dataTypes[0]&&v.accepts[v.dataTypes[0]]?v.accepts[v.dataTypes[0]]+("*"!==v.dataTypes[0]?", "+Rt+"; q=0.01":""):v.accepts["*"]),v.headers)T.setRequestHeader(i,v.headers[i]);if(v.beforeSend&&(!1===v.beforeSend.call(y,T,v)||h))return T.abort();if(u="abort",b.add(v.complete),T.done(v.success),T.fail(v.error),c=Wt(Pt,v,t,T)){if(T.readyState=1,g&&m.trigger("ajaxSend",[T,v]),h)return T;v.async&&0<v.timeout&&(d=C.setTimeout(function(){T.abort("timeout")},v.timeout));try{h=!1,c.send(a,l)}catch(e){if(h)throw e;l(-1,e)}}else l(-1,"No Transport");function l(e,t,n,r){var i,o,a,s,u,l=t;h||(h=!0,d&&C.clearTimeout(d),c=void 0,p=r||"",T.readyState=0<e?4:0,i=200<=e&&e<300||304===e,n&&(s=function(e,t,n){var r,i,o,a,s=e.contents,u=e.dataTypes;while("*"===u[0])u.shift(),void 0===r&&(r=e.mimeType||t.getResponseHeader("Content-Type"));if(r)for(i in s)if(s[i]&&s[i].test(r)){u.unshift(i);break}if(u[0]in n)o=u[0];else{for(i in n){if(!u[0]||e.converters[i+" "+u[0]]){o=i;break}a||(a=i)}o=o||a}if(o)return o!==u[0]&&u.unshift(o),n[o]}(v,T,n)),!i&&-1<S.inArray("script",v.dataTypes)&&S.inArray("json",v.dataTypes)<0&&(v.converters["text script"]=function(){}),s=function(e,t,n,r){var i,o,a,s,u,l={},c=e.dataTypes.slice();if(c[1])for(a in e.converters)l[a.toLowerCase()]=e.converters[a];o=c.shift();while(o)if(e.responseFields[o]&&(n[e.responseFields[o]]=t),!u&&r&&e.dataFilter&&(t=e.dataFilter(t,e.dataType)),u=o,o=c.shift())if("*"===o)o=u;else if("*"!==u&&u!==o){if(!(a=l[u+" "+o]||l["* "+o]))for(i in l)if((s=i.split(" "))[1]===o&&(a=l[u+" "+s[0]]||l["* "+s[0]])){!0===a?a=l[i]:!0!==l[i]&&(o=s[0],c.unshift(s[1]));break}if(!0!==a)if(a&&e["throws"])t=a(t);else try{t=a(t)}catch(e){return{state:"parsererror",error:a?e:"No conversion from "+u+" to "+o}}}return{state:"success",data:t}}(v,s,T,i),i?(v.ifModified&&((u=T.getResponseHeader("Last-Modified"))&&(S.lastModified[f]=u),(u=T.getResponseHeader("etag"))&&(S.etag[f]=u)),204===e||"HEAD"===v.type?l="nocontent":304===e?l="notmodified":(l=s.state,o=s.data,i=!(a=s.error))):(a=l,!e&&l||(l="error",e<0&&(e=0))),T.status=e,T.statusText=(t||l)+"",i?x.resolveWith(y,[o,l,T]):x.rejectWith(y,[T,l,a]),T.statusCode(w),w=void 0,g&&m.trigger(i?"ajaxSuccess":"ajaxError",[T,v,i?o:a]),b.fireWith(y,[T,l]),g&&(m.trigger("ajaxComplete",[T,v]),--S.active||S.event.trigger("ajaxStop")))}return T},getJSON:function(e,t,n){return S.get(e,t,n,"json")},getScript:function(e,t){return S.get(e,void 0,t,"script")}}),S.each(["get","post"],function(e,i){S[i]=function(e,t,n,r){return m(t)&&(r=r||n,n=t,t=void 0),S.ajax(S.extend({url:e,type:i,dataType:r,data:t,success:n},S.isPlainObject(e)&&e))}}),S.ajaxPrefilter(function(e){var t;for(t in e.headers)"content-type"===t.toLowerCase()&&(e.contentType=e.headers[t]||"")}),S._evalUrl=function(e,t,n){return S.ajax({url:e,type:"GET",dataType:"script",cache:!0,async:!1,global:!1,converters:{"text script":function(){}},dataFilter:function(e){S.globalEval(e,t,n)}})},S.fn.extend({wrapAll:function(e){var t;return this[0]&&(m(e)&&(e=e.call(this[0])),t=S(e,this[0].ownerDocument).eq(0).clone(!0),this[0].parentNode&&t.insertBefore(this[0]),t.map(function(){var e=this;while(e.firstElementChild)e=e.firstElementChild;return e}).append(this)),this},wrapInner:function(n){return m(n)?this.each(function(e){S(this).wrapInner(n.call(this,e))}):this.each(function(){var e=S(this),t=e.contents();t.length?t.wrapAll(n):e.append(n)})},wrap:function(t){var n=m(t);return this.each(function(e){S(this).wrapAll(n?t.call(this,e):t)})},unwrap:function(e){return this.parent(e).not("body").each(function(){S(this).replaceWith(this.childNodes)}),this}}),S.expr.pseudos.hidden=function(e){return!S.expr.pseudos.visible(e)},S.expr.pseudos.visible=function(e){return!!(e.offsetWidth||e.offsetHeight||e.getClientRects().length)},S.ajaxSettings.xhr=function(){try{return new C.XMLHttpRequest}catch(e){}};var Bt={0:200,1223:204},$t=S.ajaxSettings.xhr();y.cors=!!$t&&"withCredentials"in $t,y.ajax=$t=!!$t,S.ajaxTransport(function(i){var o,a;if(y.cors||$t&&!i.crossDomain)return{send:function(e,t){var n,r=i.xhr();if(r.open(i.type,i.url,i.async,i.username,i.password),i.xhrFields)for(n in i.xhrFields)r[n]=i.xhrFields[n];for(n in i.mimeType&&r.overrideMimeType&&r.overrideMimeType(i.mimeType),i.crossDomain||e["X-Requested-With"]||(e["X-Requested-With"]="XMLHttpRequest"),e)r.setRequestHeader(n,e[n]);o=function(e){return function(){o&&(o=a=r.onload=r.onerror=r.onabort=r.ontimeout=r.onreadystatechange=null,"abort"===e?r.abort():"error"===e?"number"!=typeof r.status?t(0,"error"):t(r.status,r.statusText):t(Bt[r.status]||r.status,r.statusText,"text"!==(r.responseType||"text")||"string"!=typeof r.responseText?{binary:r.response}:{text:r.responseText},r.getAllResponseHeaders()))}},r.onload=o(),a=r.onerror=r.ontimeout=o("error"),void 0!==r.onabort?r.onabort=a:r.onreadystatechange=function(){4===r.readyState&&C.setTimeout(function(){o&&a()})},o=o("abort");try{r.send(i.hasContent&&i.data||null)}catch(e){if(o)throw e}},abort:function(){o&&o()}}}),S.ajaxPrefilter(function(e){e.crossDomain&&(e.contents.script=!1)}),S.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/\b(?:java|ecma)script\b/},converters:{"text script":function(e){return S.globalEval(e),e}}}),S.ajaxPrefilter("script",function(e){void 0===e.cache&&(e.cache=!1),e.crossDomain&&(e.type="GET")}),S.ajaxTransport("script",function(n){var r,i;if(n.crossDomain||n.scriptAttrs)return{send:function(e,t){r=S("<script>").attr(n.scriptAttrs||{}).prop({charset:n.scriptCharset,src:n.url}).on("load error",i=function(e){r.remove(),i=null,e&&t("error"===e.type?404:200,e.type)}),E.head.appendChild(r[0])},abort:function(){i&&i()}}});var _t,zt=[],Ut=/(=)\?(?=&|$)|\?\?/;S.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var e=zt.pop()||S.expando+"_"+wt.guid++;return this[e]=!0,e}}),S.ajaxPrefilter("json jsonp",function(e,t,n){var r,i,o,a=!1!==e.jsonp&&(Ut.test(e.url)?"url":"string"==typeof e.data&&0===(e.contentType||"").indexOf("application/x-www-form-urlencoded")&&Ut.test(e.data)&&"data");if(a||"jsonp"===e.dataTypes[0])return r=e.jsonpCallback=m(e.jsonpCallback)?e.jsonpCallback():e.jsonpCallback,a?e[a]=e[a].replace(Ut,"$1"+r):!1!==e.jsonp&&(e.url+=(Tt.test(e.url)?"&":"?")+e.jsonp+"="+r),e.converters["script json"]=function(){return o||S.error(r+" was not called"),o[0]},e.dataTypes[0]="json",i=C[r],C[r]=function(){o=arguments},n.always(function(){void 0===i?S(C).removeProp(r):C[r]=i,e[r]&&(e.jsonpCallback=t.jsonpCallback,zt.push(r)),o&&m(i)&&i(o[0]),o=i=void 0}),"script"}),y.createHTMLDocument=((_t=E.implementation.createHTMLDocument("").body).innerHTML="<form></form><form></form>",2===_t.childNodes.length),S.parseHTML=function(e,t,n){return"string"!=typeof e?[]:("boolean"==typeof t&&(n=t,t=!1),t||(y.createHTMLDocument?((r=(t=E.implementation.createHTMLDocument("")).createElement("base")).href=E.location.href,t.head.appendChild(r)):t=E),o=!n&&[],(i=N.exec(e))?[t.createElement(i[1])]:(i=xe([e],t,o),o&&o.length&&S(o).remove(),S.merge([],i.childNodes)));var r,i,o},S.fn.load=function(e,t,n){var r,i,o,a=this,s=e.indexOf(" ");return-1<s&&(r=ht(e.slice(s)),e=e.slice(0,s)),m(t)?(n=t,t=void 0):t&&"object"==typeof t&&(i="POST"),0<a.length&&S.ajax({url:e,type:i||"GET",dataType:"html",data:t}).done(function(e){o=arguments,a.html(r?S("<div>").append(S.parseHTML(e)).find(r):e)}).always(n&&function(e,t){a.each(function(){n.apply(this,o||[e.responseText,t,e])})}),this},S.expr.pseudos.animated=function(t){return S.grep(S.timers,function(e){return t===e.elem}).length},S.offset={setOffset:function(e,t,n){var r,i,o,a,s,u,l=S.css(e,"position"),c=S(e),f={};"static"===l&&(e.style.position="relative"),s=c.offset(),o=S.css(e,"top"),u=S.css(e,"left"),("absolute"===l||"fixed"===l)&&-1<(o+u).indexOf("auto")?(a=(r=c.position()).top,i=r.left):(a=parseFloat(o)||0,i=parseFloat(u)||0),m(t)&&(t=t.call(e,n,S.extend({},s))),null!=t.top&&(f.top=t.top-s.top+a),null!=t.left&&(f.left=t.left-s.left+i),"using"in t?t.using.call(e,f):c.css(f)}},S.fn.extend({offset:function(t){if(arguments.length)return void 0===t?this:this.each(function(e){S.offset.setOffset(this,t,e)});var e,n,r=this[0];return r?r.getClientRects().length?(e=r.getBoundingClientRect(),n=r.ownerDocument.defaultView,{top:e.top+n.pageYOffset,left:e.left+n.pageXOffset}):{top:0,left:0}:void 0},position:function(){if(this[0]){var e,t,n,r=this[0],i={top:0,left:0};if("fixed"===S.css(r,"position"))t=r.getBoundingClientRect();else{t=this.offset(),n=r.ownerDocument,e=r.offsetParent||n.documentElement;while(e&&(e===n.body||e===n.documentElement)&&"static"===S.css(e,"position"))e=e.parentNode;e&&e!==r&&1===e.nodeType&&((i=S(e).offset()).top+=S.css(e,"borderTopWidth",!0),i.left+=S.css(e,"borderLeftWidth",!0))}return{top:t.top-i.top-S.css(r,"marginTop",!0),left:t.left-i.left-S.css(r,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var e=this.offsetParent;while(e&&"static"===S.css(e,"position"))e=e.offsetParent;return e||re})}}),S.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(t,i){var o="pageYOffset"===i;S.fn[t]=function(e){return $(this,function(e,t,n){var r;if(x(e)?r=e:9===e.nodeType&&(r=e.defaultView),void 0===n)return r?r[i]:e[t];r?r.scrollTo(o?r.pageXOffset:n,o?n:r.pageYOffset):e[t]=n},t,e,arguments.length)}}),S.each(["top","left"],function(e,n){S.cssHooks[n]=Fe(y.pixelPosition,function(e,t){if(t)return t=We(e,n),Pe.test(t)?S(e).position()[n]+"px":t})}),S.each({Height:"height",Width:"width"},function(a,s){S.each({padding:"inner"+a,content:s,"":"outer"+a},function(r,o){S.fn[o]=function(e,t){var n=arguments.length&&(r||"boolean"!=typeof e),i=r||(!0===e||!0===t?"margin":"border");return $(this,function(e,t,n){var r;return x(e)?0===o.indexOf("outer")?e["inner"+a]:e.document.documentElement["client"+a]:9===e.nodeType?(r=e.documentElement,Math.max(e.body["scroll"+a],r["scroll"+a],e.body["offset"+a],r["offset"+a],r["client"+a])):void 0===n?S.css(e,t,i):S.style(e,t,n,i)},s,n?e:void 0,n)}})}),S.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(e,t){S.fn[t]=function(e){return this.on(t,e)}}),S.fn.extend({bind:function(e,t,n){return this.on(e,null,t,n)},unbind:function(e,t){return this.off(e,null,t)},delegate:function(e,t,n,r){return this.on(t,e,n,r)},undelegate:function(e,t,n){return 1===arguments.length?this.off(e,"**"):this.off(t,e||"**",n)},hover:function(e,t){return this.mouseenter(e).mouseleave(t||e)}}),S.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),function(e,n){S.fn[n]=function(e,t){return 0<arguments.length?this.on(n,null,e,t):this.trigger(n)}});var Xt=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;S.proxy=function(e,t){var n,r,i;if("string"==typeof t&&(n=e[t],t=e,e=n),m(e))return r=s.call(arguments,2),(i=function(){return e.apply(t||this,r.concat(s.call(arguments)))}).guid=e.guid=e.guid||S.guid++,i},S.holdReady=function(e){e?S.readyWait++:S.ready(!0)},S.isArray=Array.isArray,S.parseJSON=JSON.parse,S.nodeName=A,S.isFunction=m,S.isWindow=x,S.camelCase=X,S.type=w,S.now=Date.now,S.isNumeric=function(e){var t=S.type(e);return("number"===t||"string"===t)&&!isNaN(e-parseFloat(e))},S.trim=function(e){return null==e?"":(e+"").replace(Xt,"")},"function"==typeof define&&define.amd&&define("jquery",[],function(){return S});var Vt=C.jQuery,Gt=C.$;return S.noConflict=function(e){return C.$===S&&(C.$=Gt),e&&C.jQuery===S&&(C.jQuery=Vt),S},"undefined"==typeof e&&(C.jQuery=C.$=S),S});
diff --git a/docs/html/_static/language_data.js b/docs/html/_static/language_data.js
index ebe2f03..250f566 100644
--- a/docs/html/_static/language_data.js
+++ b/docs/html/_static/language_data.js
@@ -5,12 +5,12 @@
  * This script contains the language-specific data used by searchtools.js,
  * namely the list of stopwords, stemmer, scorer and splitter.
  *
- * :copyright: Copyright 2007-2022 by the Sphinx team, see AUTHORS.
+ * :copyright: Copyright 2007-2023 by the Sphinx team, see AUTHORS.
  * :license: BSD, see LICENSE for details.
  *
  */
 
-var stopwords = ["a","and","are","as","at","be","but","by","for","if","in","into","is","it","near","no","not","of","on","or","such","that","the","their","then","there","these","they","this","to","was","will","with"];
+var stopwords = ["a", "and", "are", "as", "at", "be", "but", "by", "for", "if", "in", "into", "is", "it", "near", "no", "not", "of", "on", "or", "such", "that", "the", "their", "then", "there", "these", "they", "this", "to", "was", "will", "with"];
 
 
 /* Non-minified version is copied as a separate JS file, is available */
@@ -197,101 +197,3 @@ var Stemmer = function() {
   }
 }
 
-
-
-
-var splitChars = (function() {
-    var result = {};
-    var singles = [96, 180, 187, 191, 215, 247, 749, 885, 903, 907, 909, 930, 1014, 1648,
-         1748, 1809, 2416, 2473, 2481, 2526, 2601, 2609, 2612, 2615, 2653, 2702,
-         2706, 2729, 2737, 2740, 2857, 2865, 2868, 2910, 2928, 2948, 2961, 2971,
-         2973, 3085, 3089, 3113, 3124, 3213, 3217, 3241, 3252, 3295, 3341, 3345,
-         3369, 3506, 3516, 3633, 3715, 3721, 3736, 3744, 3748, 3750, 3756, 3761,
-         3781, 3912, 4239, 4347, 4681, 4695, 4697, 4745, 4785, 4799, 4801, 4823,
-         4881, 5760, 5901, 5997, 6313, 7405, 8024, 8026, 8028, 8030, 8117, 8125,
-         8133, 8181, 8468, 8485, 8487, 8489, 8494, 8527, 11311, 11359, 11687, 11695,
-         11703, 11711, 11719, 11727, 11735, 12448, 12539, 43010, 43014, 43019, 43587,
-         43696, 43713, 64286, 64297, 64311, 64317, 64319, 64322, 64325, 65141];
-    var i, j, start, end;
-    for (i = 0; i < singles.length; i++) {
-        result[singles[i]] = true;
-    }
-    var ranges = [[0, 47], [58, 64], [91, 94], [123, 169], [171, 177], [182, 184], [706, 709],
-         [722, 735], [741, 747], [751, 879], [888, 889], [894, 901], [1154, 1161],
-         [1318, 1328], [1367, 1368], [1370, 1376], [1416, 1487], [1515, 1519], [1523, 1568],
-         [1611, 1631], [1642, 1645], [1750, 1764], [1767, 1773], [1789, 1790], [1792, 1807],
-         [1840, 1868], [1958, 1968], [1970, 1983], [2027, 2035], [2038, 2041], [2043, 2047],
-         [2070, 2073], [2075, 2083], [2085, 2087], [2089, 2307], [2362, 2364], [2366, 2383],
-         [2385, 2391], [2402, 2405], [2419, 2424], [2432, 2436], [2445, 2446], [2449, 2450],
-         [2483, 2485], [2490, 2492], [2494, 2509], [2511, 2523], [2530, 2533], [2546, 2547],
-         [2554, 2564], [2571, 2574], [2577, 2578], [2618, 2648], [2655, 2661], [2672, 2673],
-         [2677, 2692], [2746, 2748], [2750, 2767], [2769, 2783], [2786, 2789], [2800, 2820],
-         [2829, 2830], [2833, 2834], [2874, 2876], [2878, 2907], [2914, 2917], [2930, 2946],
-         [2955, 2957], [2966, 2968], [2976, 2978], [2981, 2983], [2987, 2989], [3002, 3023],
-         [3025, 3045], [3059, 3076], [3130, 3132], [3134, 3159], [3162, 3167], [3170, 3173],
-         [3184, 3191], [3199, 3204], [3258, 3260], [3262, 3293], [3298, 3301], [3312, 3332],
-         [3386, 3388], [3390, 3423], [3426, 3429], [3446, 3449], [3456, 3460], [3479, 3481],
-         [3518, 3519], [3527, 3584], [3636, 3647], [3655, 3663], [3674, 3712], [3717, 3718],
-         [3723, 3724], [3726, 3731], [3752, 3753], [3764, 3772], [3774, 3775], [3783, 3791],
-         [3802, 3803], [3806, 3839], [3841, 3871], [3892, 3903], [3949, 3975], [3980, 4095],
-         [4139, 4158], [4170, 4175], [4182, 4185], [4190, 4192], [4194, 4196], [4199, 4205],
-         [4209, 4212], [4226, 4237], [4250, 4255], [4294, 4303], [4349, 4351], [4686, 4687],
-         [4702, 4703], [4750, 4751], [4790, 4791], [4806, 4807], [4886, 4887], [4955, 4968],
-         [4989, 4991], [5008, 5023], [5109, 5120], [5741, 5742], [5787, 5791], [5867, 5869],
-         [5873, 5887], [5906, 5919], [5938, 5951], [5970, 5983], [6001, 6015], [6068, 6102],
-         [6104, 6107], [6109, 6111], [6122, 6127], [6138, 6159], [6170, 6175], [6264, 6271],
-         [6315, 6319], [6390, 6399], [6429, 6469], [6510, 6511], [6517, 6527], [6572, 6592],
-         [6600, 6607], [6619, 6655], [6679, 6687], [6741, 6783], [6794, 6799], [6810, 6822],
-         [6824, 6916], [6964, 6980], [6988, 6991], [7002, 7042], [7073, 7085], [7098, 7167],
-         [7204, 7231], [7242, 7244], [7294, 7400], [7410, 7423], [7616, 7679], [7958, 7959],
-         [7966, 7967], [8006, 8007], [8014, 8015], [8062, 8063], [8127, 8129], [8141, 8143],
-         [8148, 8149], [8156, 8159], [8173, 8177], [8189, 8303], [8306, 8307], [8314, 8318],
-         [8330, 8335], [8341, 8449], [8451, 8454], [8456, 8457], [8470, 8472], [8478, 8483],
-         [8506, 8507], [8512, 8516], [8522, 8525], [8586, 9311], [9372, 9449], [9472, 10101],
-         [10132, 11263], [11493, 11498], [11503, 11516], [11518, 11519], [11558, 11567],
-         [11622, 11630], [11632, 11647], [11671, 11679], [11743, 11822], [11824, 12292],
-         [12296, 12320], [12330, 12336], [12342, 12343], [12349, 12352], [12439, 12444],
-         [12544, 12548], [12590, 12592], [12687, 12689], [12694, 12703], [12728, 12783],
-         [12800, 12831], [12842, 12880], [12896, 12927], [12938, 12976], [12992, 13311],
-         [19894, 19967], [40908, 40959], [42125, 42191], [42238, 42239], [42509, 42511],
-         [42540, 42559], [42592, 42593], [42607, 42622], [42648, 42655], [42736, 42774],
-         [42784, 42785], [42889, 42890], [42893, 43002], [43043, 43055], [43062, 43071],
-         [43124, 43137], [43188, 43215], [43226, 43249], [43256, 43258], [43260, 43263],
-         [43302, 43311], [43335, 43359], [43389, 43395], [43443, 43470], [43482, 43519],
-         [43561, 43583], [43596, 43599], [43610, 43615], [43639, 43641], [43643, 43647],
-         [43698, 43700], [43703, 43704], [43710, 43711], [43715, 43738], [43742, 43967],
-         [44003, 44015], [44026, 44031], [55204, 55215], [55239, 55242], [55292, 55295],
-         [57344, 63743], [64046, 64047], [64110, 64111], [64218, 64255], [64263, 64274],
-         [64280, 64284], [64434, 64466], [64830, 64847], [64912, 64913], [64968, 65007],
-         [65020, 65135], [65277, 65295], [65306, 65312], [65339, 65344], [65371, 65381],
-         [65471, 65473], [65480, 65481], [65488, 65489], [65496, 65497]];
-    for (i = 0; i < ranges.length; i++) {
-        start = ranges[i][0];
-        end = ranges[i][1];
-        for (j = start; j <= end; j++) {
-            result[j] = true;
-        }
-    }
-    return result;
-})();
-
-function splitQuery(query) {
-    var result = [];
-    var start = -1;
-    for (var i = 0; i < query.length; i++) {
-        if (splitChars[query.charCodeAt(i)]) {
-            if (start !== -1) {
-                result.push(query.slice(start, i));
-                start = -1;
-            }
-        } else if (start === -1) {
-            start = i;
-        }
-    }
-    if (start !== -1) {
-        result.push(query.slice(start));
-    }
-    return result;
-}
-
-
diff --git a/docs/html/_static/searchtools.js b/docs/html/_static/searchtools.js
index 2d77859..97d56a7 100644
--- a/docs/html/_static/searchtools.js
+++ b/docs/html/_static/searchtools.js
@@ -4,22 +4,24 @@
  *
  * Sphinx JavaScript utilities for the full-text search.
  *
- * :copyright: Copyright 2007-2022 by the Sphinx team, see AUTHORS.
+ * :copyright: Copyright 2007-2023 by the Sphinx team, see AUTHORS.
  * :license: BSD, see LICENSE for details.
  *
  */
+"use strict";
 
-if (!Scorer) {
-  /**
-   * Simple result scoring code.
-   */
+/**
+ * Simple result scoring code.
+ */
+if (typeof Scorer === "undefined") {
   var Scorer = {
     // Implement the following function to further tweak the score for each result
-    // The function takes a result array [filename, title, anchor, descr, score]
+    // The function takes a result array [docname, title, anchor, descr, score, filename]
     // and returns the new score.
     /*
-    score: function(result) {
-      return result[4];
+    score: result => {
+      const [docname, title, anchor, descr, score, filename] = result
+      return score
     },
     */
 
@@ -28,9 +30,11 @@ if (!Scorer) {
     // or matches in the last dotted part of the object name
     objPartialMatch: 6,
     // Additive scores depending on the priority of the object
-    objPrio: {0:  15,   // used to be importantResults
-              1:  5,   // used to be objectResults
-              2: -5},  // used to be unimportantResults
+    objPrio: {
+      0: 15, // used to be importantResults
+      1: 5, // used to be objectResults
+      2: -5, // used to be unimportantResults
+    },
     //  Used when the priority is not in the mapping.
     objPrioDefault: 0,
 
@@ -39,456 +43,495 @@ if (!Scorer) {
     partialTitle: 7,
     // query found in terms
     term: 5,
-    partialTerm: 2
+    partialTerm: 2,
   };
 }
 
-if (!splitQuery) {
-  function splitQuery(query) {
-    return query.split(/\s+/);
+const _removeChildren = (element) => {
+  while (element && element.lastChild) element.removeChild(element.lastChild);
+};
+
+/**
+ * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#escaping
+ */
+const _escapeRegExp = (string) =>
+  string.replace(/[.*+\-?^${}()|[\]\\]/g, "\\$&"); // $& means the whole matched string
+
+const _displayItem = (item, searchTerms) => {
+  const docBuilder = DOCUMENTATION_OPTIONS.BUILDER;
+  const docUrlRoot = DOCUMENTATION_OPTIONS.URL_ROOT;
+  const docFileSuffix = DOCUMENTATION_OPTIONS.FILE_SUFFIX;
+  const docLinkSuffix = DOCUMENTATION_OPTIONS.LINK_SUFFIX;
+  const showSearchSummary = DOCUMENTATION_OPTIONS.SHOW_SEARCH_SUMMARY;
+
+  const [docName, title, anchor, descr, score, _filename] = item;
+
+  let listItem = document.createElement("li");
+  let requestUrl;
+  let linkUrl;
+  if (docBuilder === "dirhtml") {
+    // dirhtml builder
+    let dirname = docName + "/";
+    if (dirname.match(/\/index\/$/))
+      dirname = dirname.substring(0, dirname.length - 6);
+    else if (dirname === "index/") dirname = "";
+    requestUrl = docUrlRoot + dirname;
+    linkUrl = requestUrl;
+  } else {
+    // normal html builders
+    requestUrl = docUrlRoot + docName + docFileSuffix;
+    linkUrl = docName + docLinkSuffix;
   }
+  let linkEl = listItem.appendChild(document.createElement("a"));
+  linkEl.href = linkUrl + anchor;
+  linkEl.dataset.score = score;
+  linkEl.innerHTML = title;
+  if (descr)
+    listItem.appendChild(document.createElement("span")).innerHTML =
+      " (" + descr + ")";
+  else if (showSearchSummary)
+    fetch(requestUrl)
+      .then((responseData) => responseData.text())
+      .then((data) => {
+        if (data)
+          listItem.appendChild(
+            Search.makeSearchSummary(data, searchTerms)
+          );
+      });
+  Search.output.appendChild(listItem);
+};
+const _finishSearch = (resultCount) => {
+  Search.stopPulse();
+  Search.title.innerText = _("Search Results");
+  if (!resultCount)
+    Search.status.innerText = Documentation.gettext(
+      "Your search did not match any documents. Please make sure that all words are spelled correctly and that you've selected enough categories."
+    );
+  else
+    Search.status.innerText = _(
+      `Search finished, found ${resultCount} page(s) matching the search query.`
+    );
+};
+const _displayNextItem = (
+  results,
+  resultCount,
+  searchTerms
+) => {
+  // results left, load the summary and display it
+  // this is intended to be dynamic (don't sub resultsCount)
+  if (results.length) {
+    _displayItem(results.pop(), searchTerms);
+    setTimeout(
+      () => _displayNextItem(results, resultCount, searchTerms),
+      5
+    );
+  }
+  // search finished, update title and status message
+  else _finishSearch(resultCount);
+};
+
+/**
+ * Default splitQuery function. Can be overridden in ``sphinx.search`` with a
+ * custom function per language.
+ *
+ * The regular expression works by splitting the string on consecutive characters
+ * that are not Unicode letters, numbers, underscores, or emoji characters.
+ * This is the same as ``\W+`` in Python, preserving the surrogate pair area.
+ */
+if (typeof splitQuery === "undefined") {
+  var splitQuery = (query) => query
+      .split(/[^\p{Letter}\p{Number}_\p{Emoji_Presentation}]+/gu)
+      .filter(term => term)  // remove remaining empty strings
 }
 
 /**
  * Search Module
  */
-var Search = {
-
-  _index : null,
-  _queued_query : null,
-  _pulse_status : -1,
-
-  htmlToText : function(htmlString) {
-      var virtualDocument = document.implementation.createHTMLDocument('virtual');
-      var htmlElement = $(htmlString, virtualDocument);
-      htmlElement.find('.headerlink').remove();
-      docContent = htmlElement.find('[role=main]')[0];
-      if(docContent === undefined) {
-          console.warn("Content block not found. Sphinx search tries to obtain it " +
-                       "via '[role=main]'. Could you check your theme or template.");
-          return "";
-      }
-      return docContent.textContent || docContent.innerText;
+const Search = {
+  _index: null,
+  _queued_query: null,
+  _pulse_status: -1,
+
+  htmlToText: (htmlString) => {
+    const htmlElement = new DOMParser().parseFromString(htmlString, 'text/html');
+    htmlElement.querySelectorAll(".headerlink").forEach((el) => { el.remove() });
+    const docContent = htmlElement.querySelector('[role="main"]');
+    if (docContent !== undefined) return docContent.textContent;
+    console.warn(
+      "Content block not found. Sphinx search tries to obtain it via '[role=main]'. Could you check your theme or template."
+    );
+    return "";
   },
 
-  init : function() {
-      var params = $.getQueryParameters();
-      if (params.q) {
-          var query = params.q[0];
-          $('input[name="q"]')[0].value = query;
-          this.performSearch(query);
-      }
+  init: () => {
+    const query = new URLSearchParams(window.location.search).get("q");
+    document
+      .querySelectorAll('input[name="q"]')
+      .forEach((el) => (el.value = query));
+    if (query) Search.performSearch(query);
   },
 
-  loadIndex : function(url) {
-    $.ajax({type: "GET", url: url, data: null,
-            dataType: "script", cache: true,
-            complete: function(jqxhr, textstatus) {
-              if (textstatus != "success") {
-                document.getElementById("searchindexloader").src = url;
-              }
-            }});
-  },
+  loadIndex: (url) =>
+    (document.body.appendChild(document.createElement("script")).src = url),
 
-  setIndex : function(index) {
-    var q;
-    this._index = index;
-    if ((q = this._queued_query) !== null) {
-      this._queued_query = null;
-      Search.query(q);
+  setIndex: (index) => {
+    Search._index = index;
+    if (Search._queued_query !== null) {
+      const query = Search._queued_query;
+      Search._queued_query = null;
+      Search.query(query);
     }
   },
 
-  hasIndex : function() {
-      return this._index !== null;
-  },
+  hasIndex: () => Search._index !== null,
 
-  deferQuery : function(query) {
-      this._queued_query = query;
-  },
+  deferQuery: (query) => (Search._queued_query = query),
 
-  stopPulse : function() {
-      this._pulse_status = 0;
-  },
+  stopPulse: () => (Search._pulse_status = -1),
 
-  startPulse : function() {
-    if (this._pulse_status >= 0)
-        return;
-    function pulse() {
-      var i;
+  startPulse: () => {
+    if (Search._pulse_status >= 0) return;
+
+    const pulse = () => {
       Search._pulse_status = (Search._pulse_status + 1) % 4;
-      var dotString = '';
-      for (i = 0; i < Search._pulse_status; i++)
-        dotString += '.';
-      Search.dots.text(dotString);
-      if (Search._pulse_status > -1)
-        window.setTimeout(pulse, 500);
-    }
+      Search.dots.innerText = ".".repeat(Search._pulse_status);
+      if (Search._pulse_status >= 0) window.setTimeout(pulse, 500);
+    };
     pulse();
   },
 
   /**
    * perform a search for something (or wait until index is loaded)
    */
-  performSearch : function(query) {
+  performSearch: (query) => {
     // create the required interface elements
-    this.out = $('#search-results');
-    this.title = $('<h2>' + _('Searching') + '</h2>').appendTo(this.out);
-    this.dots = $('<span></span>').appendTo(this.title);
-    this.status = $('<p class="search-summary">&nbsp;</p>').appendTo(this.out);
-    this.output = $('<ul class="search"/>').appendTo(this.out);
-
-    $('#search-progress').text(_('Preparing search...'));
-    this.startPulse();
+    const searchText = document.createElement("h2");
+    searchText.textContent = _("Searching");
+    const searchSummary = document.createElement("p");
+    searchSummary.classList.add("search-summary");
+    searchSummary.innerText = "";
+    const searchList = document.createElement("ul");
+    searchList.classList.add("search");
+
+    const out = document.getElementById("search-results");
+    Search.title = out.appendChild(searchText);
+    Search.dots = Search.title.appendChild(document.createElement("span"));
+    Search.status = out.appendChild(searchSummary);
+    Search.output = out.appendChild(searchList);
+
+    const searchProgress = document.getElementById("search-progress");
+    // Some themes don't use the search progress node
+    if (searchProgress) {
+      searchProgress.innerText = _("Preparing search...");
+    }
+    Search.startPulse();
 
     // index already loaded, the browser was quick!
-    if (this.hasIndex())
-      this.query(query);
-    else
-      this.deferQuery(query);
+    if (Search.hasIndex()) Search.query(query);
+    else Search.deferQuery(query);
   },
 
   /**
    * execute search (requires search index to be loaded)
    */
-  query : function(query) {
-    var i;
-
-    // stem the searchterms and add them to the correct list
-    var stemmer = new Stemmer();
-    var searchterms = [];
-    var excluded = [];
-    var hlterms = [];
-    var tmp = splitQuery(query);
-    var objectterms = [];
-    for (i = 0; i < tmp.length; i++) {
-      if (tmp[i] !== "") {
-          objectterms.push(tmp[i].toLowerCase());
-      }
+  query: (query) => {
+    const filenames = Search._index.filenames;
+    const docNames = Search._index.docnames;
+    const titles = Search._index.titles;
+    const allTitles = Search._index.alltitles;
+    const indexEntries = Search._index.indexentries;
+
+    // stem the search terms and add them to the correct list
+    const stemmer = new Stemmer();
+    const searchTerms = new Set();
+    const excludedTerms = new Set();
+    const highlightTerms = new Set();
+    const objectTerms = new Set(splitQuery(query.toLowerCase().trim()));
+    splitQuery(query.trim()).forEach((queryTerm) => {
+      const queryTermLower = queryTerm.toLowerCase();
+
+      // maybe skip this "word"
+      // stopwords array is from language_data.js
+      if (
+        stopwords.indexOf(queryTermLower) !== -1 ||
+        queryTerm.match(/^\d+$/)
+      )
+        return;
 
-      if ($u.indexOf(stopwords, tmp[i].toLowerCase()) != -1 || tmp[i] === "") {
-        // skip this "word"
-        continue;
-      }
       // stem the word
-      var word = stemmer.stemWord(tmp[i].toLowerCase());
-      // prevent stemmer from cutting word smaller than two chars
-      if(word.length < 3 && tmp[i].length >= 3) {
-        word = tmp[i];
-      }
-      var toAppend;
+      let word = stemmer.stemWord(queryTermLower);
       // select the correct list
-      if (word[0] == '-') {
-        toAppend = excluded;
-        word = word.substr(1);
-      }
+      if (word[0] === "-") excludedTerms.add(word.substr(1));
       else {
-        toAppend = searchterms;
-        hlterms.push(tmp[i].toLowerCase());
+        searchTerms.add(word);
+        highlightTerms.add(queryTermLower);
       }
-      // only add if not already in the list
-      if (!$u.contains(toAppend, word))
-        toAppend.push(word);
-    }
-    var highlightstring = '?highlight=' + $.urlencode(hlterms.join(" "));
+    });
 
-    // console.debug('SEARCH: searching for:');
-    // console.info('required: ', searchterms);
-    // console.info('excluded: ', excluded);
+    if (SPHINX_HIGHLIGHT_ENABLED) {  // set in sphinx_highlight.js
+      localStorage.setItem("sphinx_highlight_terms", [...highlightTerms].join(" "))
+    }
 
-    // prepare search
-    var terms = this._index.terms;
-    var titleterms = this._index.titleterms;
+    // console.debug("SEARCH: searching for:");
+    // console.info("required: ", [...searchTerms]);
+    // console.info("excluded: ", [...excludedTerms]);
+
+    // array of [docname, title, anchor, descr, score, filename]
+    let results = [];
+    _removeChildren(document.getElementById("search-progress"));
+
+    const queryLower = query.toLowerCase();
+    for (const [title, foundTitles] of Object.entries(allTitles)) {
+      if (title.toLowerCase().includes(queryLower) && (queryLower.length >= title.length/2)) {
+        for (const [file, id] of foundTitles) {
+          let score = Math.round(100 * queryLower.length / title.length)
+          results.push([
+            docNames[file],
+            titles[file] !== title ? `${titles[file]} > ${title}` : title,
+            id !== null ? "#" + id : "",
+            null,
+            score,
+            filenames[file],
+          ]);
+        }
+      }
+    }
 
-    // array of [filename, title, anchor, descr, score]
-    var results = [];
-    $('#search-progress').empty();
+    // search for explicit entries in index directives
+    for (const [entry, foundEntries] of Object.entries(indexEntries)) {
+      if (entry.includes(queryLower) && (queryLower.length >= entry.length/2)) {
+        for (const [file, id] of foundEntries) {
+          let score = Math.round(100 * queryLower.length / entry.length)
+          results.push([
+            docNames[file],
+            titles[file],
+            id ? "#" + id : "",
+            null,
+            score,
+            filenames[file],
+          ]);
+        }
+      }
+    }
 
     // lookup as object
-    for (i = 0; i < objectterms.length; i++) {
-      var others = [].concat(objectterms.slice(0, i),
-                             objectterms.slice(i+1, objectterms.length));
-      results = results.concat(this.performObjectSearch(objectterms[i], others));
-    }
+    objectTerms.forEach((term) =>
+      results.push(...Search.performObjectSearch(term, objectTerms))
+    );
 
     // lookup as search terms in fulltext
-    results = results.concat(this.performTermsSearch(searchterms, excluded, terms, titleterms));
+    results.push(...Search.performTermsSearch(searchTerms, excludedTerms));
 
     // let the scorer override scores with a custom scoring function
-    if (Scorer.score) {
-      for (i = 0; i < results.length; i++)
-        results[i][4] = Scorer.score(results[i]);
-    }
+    if (Scorer.score) results.forEach((item) => (item[4] = Scorer.score(item)));
 
     // now sort the results by score (in opposite order of appearance, since the
     // display function below uses pop() to retrieve items) and then
     // alphabetically
-    results.sort(function(a, b) {
-      var left = a[4];
-      var right = b[4];
-      if (left > right) {
-        return 1;
-      } else if (left < right) {
-        return -1;
-      } else {
+    results.sort((a, b) => {
+      const leftScore = a[4];
+      const rightScore = b[4];
+      if (leftScore === rightScore) {
         // same score: sort alphabetically
-        left = a[1].toLowerCase();
-        right = b[1].toLowerCase();
-        return (left > right) ? -1 : ((left < right) ? 1 : 0);
+        const leftTitle = a[1].toLowerCase();
+        const rightTitle = b[1].toLowerCase();
+        if (leftTitle === rightTitle) return 0;
+        return leftTitle > rightTitle ? -1 : 1; // inverted is intentional
       }
+      return leftScore > rightScore ? 1 : -1;
     });
 
+    // remove duplicate search results
+    // note the reversing of results, so that in the case of duplicates, the highest-scoring entry is kept
+    let seen = new Set();
+    results = results.reverse().reduce((acc, result) => {
+      let resultStr = result.slice(0, 4).concat([result[5]]).map(v => String(v)).join(',');
+      if (!seen.has(resultStr)) {
+        acc.push(result);
+        seen.add(resultStr);
+      }
+      return acc;
+    }, []);
+
+    results = results.reverse();
+
     // for debugging
     //Search.lastresults = results.slice();  // a copy
-    //console.info('search results:', Search.lastresults);
+    // console.info("search results:", Search.lastresults);
 
     // print the results
-    var resultCount = results.length;
-    function displayNextItem() {
-      // results left, load the summary and display it
-      if (results.length) {
-        var item = results.pop();
-        var listItem = $('<li></li>');
-        var requestUrl = "";
-        var linkUrl = "";
-        if (DOCUMENTATION_OPTIONS.BUILDER === 'dirhtml') {
-          // dirhtml builder
-          var dirname = item[0] + '/';
-          if (dirname.match(/\/index\/$/)) {
-            dirname = dirname.substring(0, dirname.length-6);
-          } else if (dirname == 'index/') {
-            dirname = '';
-          }
-          requestUrl = DOCUMENTATION_OPTIONS.URL_ROOT + dirname;
-          linkUrl = requestUrl;
-
-        } else {
-          // normal html builders
-          requestUrl = DOCUMENTATION_OPTIONS.URL_ROOT + item[0] + DOCUMENTATION_OPTIONS.FILE_SUFFIX;
-          linkUrl = item[0] + DOCUMENTATION_OPTIONS.LINK_SUFFIX;
-        }
-        listItem.append($('<a/>').attr('href',
-            linkUrl +
-            highlightstring + item[2]).html(item[1]));
-        if (item[3]) {
-          listItem.append($('<span> (' + item[3] + ')</span>'));
-          Search.output.append(listItem);
-          setTimeout(function() {
-            displayNextItem();
-          }, 5);
-        } else if (DOCUMENTATION_OPTIONS.HAS_SOURCE) {
-          $.ajax({url: requestUrl,
-                  dataType: "text",
-                  complete: function(jqxhr, textstatus) {
-                    var data = jqxhr.responseText;
-                    if (data !== '' && data !== undefined) {
-                      var summary = Search.makeSearchSummary(data, searchterms, hlterms);
-                      if (summary) {
-                        listItem.append(summary);
-                      }
-                    }
-                    Search.output.append(listItem);
-                    setTimeout(function() {
-                      displayNextItem();
-                    }, 5);
-                  }});
-        } else {
-          // no source available, just display title
-          Search.output.append(listItem);
-          setTimeout(function() {
-            displayNextItem();
-          }, 5);
-        }
-      }
-      // search finished, update title and status message
-      else {
-        Search.stopPulse();
-        Search.title.text(_('Search Results'));
-        if (!resultCount)
-          Search.status.text(_('Your search did not match any documents. Please make sure that all words are spelled correctly and that you\'ve selected enough categories.'));
-        else
-            Search.status.text(_('Search finished, found %s page(s) matching the search query.').replace('%s', resultCount));
-        Search.status.fadeIn(500);
-      }
-    }
-    displayNextItem();
+    _displayNextItem(results, results.length, searchTerms);
   },
 
   /**
    * search for object names
    */
-  performObjectSearch : function(object, otherterms) {
-    var filenames = this._index.filenames;
-    var docnames = this._index.docnames;
-    var objects = this._index.objects;
-    var objnames = this._index.objnames;
-    var titles = this._index.titles;
-
-    var i;
-    var results = [];
-
-    for (var prefix in objects) {
-      for (var iMatch = 0; iMatch != objects[prefix].length; ++iMatch) {
-        var match = objects[prefix][iMatch];
-        var name = match[4];
-        var fullname = (prefix ? prefix + '.' : '') + name;
-        var fullnameLower = fullname.toLowerCase()
-        if (fullnameLower.indexOf(object) > -1) {
-          var score = 0;
-          var parts = fullnameLower.split('.');
-          // check for different match types: exact matches of full name or
-          // "last name" (i.e. last dotted part)
-          if (fullnameLower == object || parts[parts.length - 1] == object) {
-            score += Scorer.objNameMatch;
-          // matches in last name
-          } else if (parts[parts.length - 1].indexOf(object) > -1) {
-            score += Scorer.objPartialMatch;
-          }
-          var objname = objnames[match[1]][2];
-          var title = titles[match[0]];
-          // If more than one term searched for, we require other words to be
-          // found in the name/title/description
-          if (otherterms.length > 0) {
-            var haystack = (prefix + ' ' + name + ' ' +
-                            objname + ' ' + title).toLowerCase();
-            var allfound = true;
-            for (i = 0; i < otherterms.length; i++) {
-              if (haystack.indexOf(otherterms[i]) == -1) {
-                allfound = false;
-                break;
-              }
-            }
-            if (!allfound) {
-              continue;
-            }
-          }
-          var descr = objname + _(', in ') + title;
-
-          var anchor = match[3];
-          if (anchor === '')
-            anchor = fullname;
-          else if (anchor == '-')
-            anchor = objnames[match[1]][1] + '-' + fullname;
-          // add custom score for some objects according to scorer
-          if (Scorer.objPrio.hasOwnProperty(match[2])) {
-            score += Scorer.objPrio[match[2]];
-          } else {
-            score += Scorer.objPrioDefault;
-          }
-          results.push([docnames[match[0]], fullname, '#'+anchor, descr, score, filenames[match[0]]]);
-        }
+  performObjectSearch: (object, objectTerms) => {
+    const filenames = Search._index.filenames;
+    const docNames = Search._index.docnames;
+    const objects = Search._index.objects;
+    const objNames = Search._index.objnames;
+    const titles = Search._index.titles;
+
+    const results = [];
+
+    const objectSearchCallback = (prefix, match) => {
+      const name = match[4]
+      const fullname = (prefix ? prefix + "." : "") + name;
+      const fullnameLower = fullname.toLowerCase();
+      if (fullnameLower.indexOf(object) < 0) return;
+
+      let score = 0;
+      const parts = fullnameLower.split(".");
+
+      // check for different match types: exact matches of full name or
+      // "last name" (i.e. last dotted part)
+      if (fullnameLower === object || parts.slice(-1)[0] === object)
+        score += Scorer.objNameMatch;
+      else if (parts.slice(-1)[0].indexOf(object) > -1)
+        score += Scorer.objPartialMatch; // matches in last name
+
+      const objName = objNames[match[1]][2];
+      const title = titles[match[0]];
+
+      // If more than one term searched for, we require other words to be
+      // found in the name/title/description
+      const otherTerms = new Set(objectTerms);
+      otherTerms.delete(object);
+      if (otherTerms.size > 0) {
+        const haystack = `${prefix} ${name} ${objName} ${title}`.toLowerCase();
+        if (
+          [...otherTerms].some((otherTerm) => haystack.indexOf(otherTerm) < 0)
+        )
+          return;
       }
-    }
 
+      let anchor = match[3];
+      if (anchor === "") anchor = fullname;
+      else if (anchor === "-") anchor = objNames[match[1]][1] + "-" + fullname;
+
+      const descr = objName + _(", in ") + title;
+
+      // add custom score for some objects according to scorer
+      if (Scorer.objPrio.hasOwnProperty(match[2]))
+        score += Scorer.objPrio[match[2]];
+      else score += Scorer.objPrioDefault;
+
+      results.push([
+        docNames[match[0]],
+        fullname,
+        "#" + anchor,
+        descr,
+        score,
+        filenames[match[0]],
+      ]);
+    };
+    Object.keys(objects).forEach((prefix) =>
+      objects[prefix].forEach((array) =>
+        objectSearchCallback(prefix, array)
+      )
+    );
     return results;
   },
 
-  /**
-   * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions
-   */
-  escapeRegExp : function(string) {
-    return string.replace(/[.*+\-?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
-  },
-
   /**
    * search for full-text terms in the index
    */
-  performTermsSearch : function(searchterms, excluded, terms, titleterms) {
-    var docnames = this._index.docnames;
-    var filenames = this._index.filenames;
-    var titles = this._index.titles;
+  performTermsSearch: (searchTerms, excludedTerms) => {
+    // prepare search
+    const terms = Search._index.terms;
+    const titleTerms = Search._index.titleterms;
+    const filenames = Search._index.filenames;
+    const docNames = Search._index.docnames;
+    const titles = Search._index.titles;
 
-    var i, j, file;
-    var fileMap = {};
-    var scoreMap = {};
-    var results = [];
+    const scoreMap = new Map();
+    const fileMap = new Map();
 
     // perform the search on the required terms
-    for (i = 0; i < searchterms.length; i++) {
-      var word = searchterms[i];
-      var files = [];
-      var _o = [
-        {files: terms[word], score: Scorer.term},
-        {files: titleterms[word], score: Scorer.title}
+    searchTerms.forEach((word) => {
+      const files = [];
+      const arr = [
+        { files: terms[word], score: Scorer.term },
+        { files: titleTerms[word], score: Scorer.title },
       ];
       // add support for partial matches
       if (word.length > 2) {
-        var word_regex = this.escapeRegExp(word);
-        for (var w in terms) {
-          if (w.match(word_regex) && !terms[word]) {
-            _o.push({files: terms[w], score: Scorer.partialTerm})
-          }
-        }
-        for (var w in titleterms) {
-          if (w.match(word_regex) && !titleterms[word]) {
-              _o.push({files: titleterms[w], score: Scorer.partialTitle})
-          }
-        }
+        const escapedWord = _escapeRegExp(word);
+        Object.keys(terms).forEach((term) => {
+          if (term.match(escapedWord) && !terms[word])
+            arr.push({ files: terms[term], score: Scorer.partialTerm });
+        });
+        Object.keys(titleTerms).forEach((term) => {
+          if (term.match(escapedWord) && !titleTerms[word])
+            arr.push({ files: titleTerms[word], score: Scorer.partialTitle });
+        });
       }
 
       // no match but word was a required one
-      if ($u.every(_o, function(o){return o.files === undefined;})) {
-        break;
-      }
+      if (arr.every((record) => record.files === undefined)) return;
+
       // found search word in contents
-      $u.each(_o, function(o) {
-        var _files = o.files;
-        if (_files === undefined)
-          return
-
-        if (_files.length === undefined)
-          _files = [_files];
-        files = files.concat(_files);
-
-        // set score for the word in each file to Scorer.term
-        for (j = 0; j < _files.length; j++) {
-          file = _files[j];
-          if (!(file in scoreMap))
-            scoreMap[file] = {};
-          scoreMap[file][word] = o.score;
-        }
+      arr.forEach((record) => {
+        if (record.files === undefined) return;
+
+        let recordFiles = record.files;
+        if (recordFiles.length === undefined) recordFiles = [recordFiles];
+        files.push(...recordFiles);
+
+        // set score for the word in each file
+        recordFiles.forEach((file) => {
+          if (!scoreMap.has(file)) scoreMap.set(file, {});
+          scoreMap.get(file)[word] = record.score;
+        });
       });
 
       // create the mapping
-      for (j = 0; j < files.length; j++) {
-        file = files[j];
-        if (file in fileMap && fileMap[file].indexOf(word) === -1)
-          fileMap[file].push(word);
-        else
-          fileMap[file] = [word];
-      }
-    }
+      files.forEach((file) => {
+        if (fileMap.has(file) && fileMap.get(file).indexOf(word) === -1)
+          fileMap.get(file).push(word);
+        else fileMap.set(file, [word]);
+      });
+    });
 
     // now check if the files don't contain excluded terms
-    for (file in fileMap) {
-      var valid = true;
-
+    const results = [];
+    for (const [file, wordList] of fileMap) {
       // check if all requirements are matched
-      var filteredTermCount = // as search terms with length < 3 are discarded: ignore
-        searchterms.filter(function(term){return term.length > 2}).length
+
+      // as search terms with length < 3 are discarded
+      const filteredTermCount = [...searchTerms].filter(
+        (term) => term.length > 2
+      ).length;
       if (
-        fileMap[file].length != searchterms.length &&
-        fileMap[file].length != filteredTermCount
-      ) continue;
+        wordList.length !== searchTerms.size &&
+        wordList.length !== filteredTermCount
+      )
+        continue;
 
       // ensure that none of the excluded terms is in the search result
-      for (i = 0; i < excluded.length; i++) {
-        if (terms[excluded[i]] == file ||
-            titleterms[excluded[i]] == file ||
-            $u.contains(terms[excluded[i]] || [], file) ||
-            $u.contains(titleterms[excluded[i]] || [], file)) {
-          valid = false;
-          break;
-        }
-      }
+      if (
+        [...excludedTerms].some(
+          (term) =>
+            terms[term] === file ||
+            titleTerms[term] === file ||
+            (terms[term] || []).includes(file) ||
+            (titleTerms[term] || []).includes(file)
+        )
+      )
+        break;
 
-      // if we have still a valid result we can add it to the result list
-      if (valid) {
-        // select one (max) score for the file.
-        // for better ranking, we should calculate ranking by using words statistics like basic tf-idf...
-        var score = $u.max($u.map(fileMap[file], function(w){return scoreMap[file][w]}));
-        results.push([docnames[file], titles[file], '', null, score, filenames[file]]);
-      }
+      // select one (max) score for the file.
+      const score = Math.max(...wordList.map((w) => scoreMap.get(file)[w]));
+      // add result to the result list
+      results.push([
+        docNames[file],
+        titles[file],
+        "",
+        null,
+        score,
+        filenames[file],
+      ]);
     }
     return results;
   },
@@ -496,34 +539,28 @@ var Search = {
   /**
    * helper function to return a node containing the
    * search summary for a given text. keywords is a list
-   * of stemmed words, hlwords is the list of normal, unstemmed
-   * words. the first one is used to find the occurrence, the
-   * latter for highlighting it.
+   * of stemmed words.
    */
-  makeSearchSummary : function(htmlText, keywords, hlwords) {
-    var text = Search.htmlToText(htmlText);
-    if (text == "") {
-      return null;
-    }
-    var textLower = text.toLowerCase();
-    var start = 0;
-    $.each(keywords, function() {
-      var i = textLower.indexOf(this.toLowerCase());
-      if (i > -1)
-        start = i;
-    });
-    start = Math.max(start - 120, 0);
-    var excerpt = ((start > 0) ? '...' : '') +
-      $.trim(text.substr(start, 240)) +
-      ((start + 240 - text.length) ? '...' : '');
-    var rv = $('<p class="context"></p>').text(excerpt);
-    $.each(hlwords, function() {
-      rv = rv.highlightText(this, 'highlighted');
-    });
-    return rv;
-  }
+  makeSearchSummary: (htmlText, keywords) => {
+    const text = Search.htmlToText(htmlText);
+    if (text === "") return null;
+
+    const textLower = text.toLowerCase();
+    const actualStartPosition = [...keywords]
+      .map((k) => textLower.indexOf(k.toLowerCase()))
+      .filter((i) => i > -1)
+      .slice(-1)[0];
+    const startWithContext = Math.max(actualStartPosition - 120, 0);
+
+    const top = startWithContext === 0 ? "" : "...";
+    const tail = startWithContext + 240 < text.length ? "..." : "";
+
+    let summary = document.createElement("p");
+    summary.classList.add("context");
+    summary.textContent = top + text.substr(startWithContext, 240).trim() + tail;
+
+    return summary;
+  },
 };
 
-$(document).ready(function() {
-  Search.init();
-});
+_ready(Search.init);
diff --git a/docs/html/_static/sphinx_highlight.js b/docs/html/_static/sphinx_highlight.js
new file mode 100644
index 0000000..aae669d
--- /dev/null
+++ b/docs/html/_static/sphinx_highlight.js
@@ -0,0 +1,144 @@
+/* Highlighting utilities for Sphinx HTML documentation. */
+"use strict";
+
+const SPHINX_HIGHLIGHT_ENABLED = true
+
+/**
+ * highlight a given string on a node by wrapping it in
+ * span elements with the given class name.
+ */
+const _highlight = (node, addItems, text, className) => {
+  if (node.nodeType === Node.TEXT_NODE) {
+    const val = node.nodeValue;
+    const parent = node.parentNode;
+    const pos = val.toLowerCase().indexOf(text);
+    if (
+      pos >= 0 &&
+      !parent.classList.contains(className) &&
+      !parent.classList.contains("nohighlight")
+    ) {
+      let span;
+
+      const closestNode = parent.closest("body, svg, foreignObject");
+      const isInSVG = closestNode && closestNode.matches("svg");
+      if (isInSVG) {
+        span = document.createElementNS("http://www.w3.org/2000/svg", "tspan");
+      } else {
+        span = document.createElement("span");
+        span.classList.add(className);
+      }
+
+      span.appendChild(document.createTextNode(val.substr(pos, text.length)));
+      parent.insertBefore(
+        span,
+        parent.insertBefore(
+          document.createTextNode(val.substr(pos + text.length)),
+          node.nextSibling
+        )
+      );
+      node.nodeValue = val.substr(0, pos);
+
+      if (isInSVG) {
+        const rect = document.createElementNS(
+          "http://www.w3.org/2000/svg",
+          "rect"
+        );
+        const bbox = parent.getBBox();
+        rect.x.baseVal.value = bbox.x;
+        rect.y.baseVal.value = bbox.y;
+        rect.width.baseVal.value = bbox.width;
+        rect.height.baseVal.value = bbox.height;
+        rect.setAttribute("class", className);
+        addItems.push({ parent: parent, target: rect });
+      }
+    }
+  } else if (node.matches && !node.matches("button, select, textarea")) {
+    node.childNodes.forEach((el) => _highlight(el, addItems, text, className));
+  }
+};
+const _highlightText = (thisNode, text, className) => {
+  let addItems = [];
+  _highlight(thisNode, addItems, text, className);
+  addItems.forEach((obj) =>
+    obj.parent.insertAdjacentElement("beforebegin", obj.target)
+  );
+};
+
+/**
+ * Small JavaScript module for the documentation.
+ */
+const SphinxHighlight = {
+
+  /**
+   * highlight the search words provided in localstorage in the text
+   */
+  highlightSearchWords: () => {
+    if (!SPHINX_HIGHLIGHT_ENABLED) return;  // bail if no highlight
+
+    // get and clear terms from localstorage
+    const url = new URL(window.location);
+    const highlight =
+        localStorage.getItem("sphinx_highlight_terms")
+        || url.searchParams.get("highlight")
+        || "";
+    localStorage.removeItem("sphinx_highlight_terms")
+    url.searchParams.delete("highlight");
+    window.history.replaceState({}, "", url);
+
+    // get individual terms from highlight string
+    const terms = highlight.toLowerCase().split(/\s+/).filter(x => x);
+    if (terms.length === 0) return; // nothing to do
+
+    // There should never be more than one element matching "div.body"
+    const divBody = document.querySelectorAll("div.body");
+    const body = divBody.length ? divBody[0] : document.querySelector("body");
+    window.setTimeout(() => {
+      terms.forEach((term) => _highlightText(body, term, "highlighted"));
+    }, 10);
+
+    const searchBox = document.getElementById("searchbox");
+    if (searchBox === null) return;
+    searchBox.appendChild(
+      document
+        .createRange()
+        .createContextualFragment(
+          '<p class="highlight-link">' +
+            '<a href="javascript:SphinxHighlight.hideSearchWords()">' +
+            _("Hide Search Matches") +
+            "</a></p>"
+        )
+    );
+  },
+
+  /**
+   * helper function to hide the search marks again
+   */
+  hideSearchWords: () => {
+    document
+      .querySelectorAll("#searchbox .highlight-link")
+      .forEach((el) => el.remove());
+    document
+      .querySelectorAll("span.highlighted")
+      .forEach((el) => el.classList.remove("highlighted"));
+    localStorage.removeItem("sphinx_highlight_terms")
+  },
+
+  initEscapeListener: () => {
+    // only install a listener if it is really needed
+    if (!DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS) return;
+
+    document.addEventListener("keydown", (event) => {
+      // bail for input elements
+      if (BLACKLISTED_KEY_CONTROL_ELEMENTS.has(document.activeElement.tagName)) return;
+      // bail with special keys
+      if (event.shiftKey || event.altKey || event.ctrlKey || event.metaKey) return;
+      if (DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS && (event.key === "Escape")) {
+        SphinxHighlight.hideSearchWords();
+        event.preventDefault();
+      }
+    });
+  },
+};
+
+_ready(SphinxHighlight.highlightSearchWords);
+_ready(SphinxHighlight.initEscapeListener);
diff --git a/docs/html/acquisition.html b/docs/html/acquisition.html
index 856516b..47ad7ee 100644
--- a/docs/html/acquisition.html
+++ b/docs/html/acquisition.html
@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html class="writer-html5" lang="en" >
 <head>
-  <meta charset="utf-8" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
+  <meta charset="utf-8" /><meta name="generator" content="Docutils 0.18.1: http://docutils.sourceforge.net/" />
 
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <title>Acquisition control &mdash; GEN DAQ API - Python Driver 1.1 documentation</title>
@@ -11,10 +11,11 @@
     <script src="_static/js/html5shiv.min.js"></script>
   <![endif]-->
   
-        <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
         <script src="_static/jquery.js"></script>
-        <script src="_static/underscore.js"></script>
+        <script src="_static/_sphinx_javascript_frameworks_compat.js"></script>
+        <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
         <script src="_static/doctools.js"></script>
+        <script src="_static/sphinx_highlight.js"></script>
     <script src="_static/js/theme.js"></script>
     <link rel="index" title="Index" href="genindex.html" />
     <link rel="search" title="Search" href="search.html" />
@@ -27,11 +28,15 @@
     <nav data-toggle="wy-nav-shift" class="wy-nav-side">
       <div class="wy-side-scroll">
         <div class="wy-side-nav-search" >
-            <a href="index.html" class="icon icon-home"> GEN DAQ API - Python Driver
+
+          
+          
+          <a href="index.html" class="icon icon-home">
+            GEN DAQ API - Python Driver
           </a>
 <div role="search">
   <form id="rtd-search-form" class="wy-form" action="search.html" method="get">
-    <input type="text" name="q" placeholder="Search docs" />
+    <input type="text" name="q" placeholder="Search docs" aria-label="Search docs" />
     <input type="hidden" name="check_keywords" value="yes" />
     <input type="hidden" name="area" value="default" />
   </form>
@@ -43,7 +48,19 @@
 <li class="toctree-l1 current"><a class="reference internal" href="releasenotes.html">Release Notes</a><ul class="current">
 <li class="toctree-l2 current"><a class="reference internal" href="releasenotes.html#version-1-0">Version 1.0</a><ul class="current">
 <li class="toctree-l3"><a class="reference internal" href="connections.html">Connections</a></li>
-<li class="toctree-l3 current"><a class="current reference internal" href="#">Acquisition control</a></li>
+<li class="toctree-l3 current"><a class="current reference internal" href="#">Acquisition control</a><ul>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_start_preview"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_start_preview()</span></code></a></li>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_stop_preview"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_stop_preview()</span></code></a></li>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_start_recording"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_start_recording()</span></code></a></li>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_pause_recording"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_pause_recording()</span></code></a></li>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_resume_recording"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_resume_recording()</span></code></a></li>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_stop_recording"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_stop_recording()</span></code></a></li>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_trigger"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_trigger()</span></code></a></li>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_get_acquisition_state"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_acquisition_state()</span></code></a></li>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_get_acquisition_time"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_acquisition_time()</span></code></a></li>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_get_acquisition_start_time"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_acquisition_start_time()</span></code></a></li>
+</ul>
+</li>
 <li class="toctree-l3"><a class="reference internal" href="mainframe.html">Mainframe</a></li>
 <li class="toctree-l3"><a class="reference internal" href="managerecording.html">Manage recordings</a></li>
 <li class="toctree-l3"><a class="reference internal" href="managemainframe.html">Manage mainframe settings</a></li>
@@ -69,9 +86,9 @@
         <div class="rst-content">
           <div role="navigation" aria-label="Page navigation">
   <ul class="wy-breadcrumbs">
-      <li><a href="index.html" class="icon icon-home"></a> &raquo;</li>
-          <li><a href="ghspyapi.html">API Functions</a> &raquo;</li>
-      <li>Acquisition control</li>
+      <li><a href="index.html" class="icon icon-home" aria-label="Home"></a></li>
+          <li class="breadcrumb-item"><a href="ghspyapi.html">API Functions</a></li>
+      <li class="breadcrumb-item active">Acquisition control</li>
       <li class="wy-breadcrumbs-aside">
             <a href="_sources/acquisition.rst.txt" rel="nofollow"> View page source</a>
       </li>
@@ -82,7 +99,7 @@
            <div itemprop="articleBody">
              
   <section id="acquisition-control">
-<h1>Acquisition control<a class="headerlink" href="#acquisition-control" title="Permalink to this headline"></a></h1>
+<h1>Acquisition control<a class="headerlink" href="#acquisition-control" title="Permalink to this heading"></a></h1>
 <p>Acquisition control related API functions.</p>
 <dl class="py method">
 <dt class="sig sig-object py" id="ghsapi.ghsapi.GHS.ghs_start_preview">
@@ -90,7 +107,7 @@ <h1>Acquisition control<a class="headerlink" href="#acquisition-control" title="
 <dd><p>Starts preview mode.</p>
 <p><em>The system needs to be idle before calling this function.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Returns</dt>
+<dt class="field-odd">Returns<span class="colon">:</span></dt>
 <dd class="field-odd"><p><ul class="simple">
 <li><p>GHSReturnValue - Start preview status.</p></li>
 </ul>
@@ -106,7 +123,7 @@ <h1>Acquisition control<a class="headerlink" href="#acquisition-control" title="
 <p><em>The system needs to be in preview mode before calling this
 function.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Returns</dt>
+<dt class="field-odd">Returns<span class="colon">:</span></dt>
 <dd class="field-odd"><p><ul class="simple">
 <li><p>GHSReturnValue - Stop preview status.</p></li>
 </ul>
@@ -124,7 +141,7 @@ <h1>Acquisition control<a class="headerlink" href="#acquisition-control" title="
 This command can be executed only successfully when the local
 storage is set.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Returns</dt>
+<dt class="field-odd">Returns<span class="colon">:</span></dt>
 <dd class="field-odd"><p><ul class="simple">
 <li><p>GHSReturnValue - Start recording status.</p></li>
 </ul>
@@ -139,7 +156,7 @@ <h1>Acquisition control<a class="headerlink" href="#acquisition-control" title="
 <dd><p>Pauses a started recording.</p>
 <p><em>The system needs to be recording before calling this function.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Returns</dt>
+<dt class="field-odd">Returns<span class="colon">:</span></dt>
 <dd class="field-odd"><p><ul class="simple">
 <li><p>GHSReturnValue - Pause recording status.</p></li>
 </ul>
@@ -154,7 +171,7 @@ <h1>Acquisition control<a class="headerlink" href="#acquisition-control" title="
 <dd><p>Resumes a paused recording.</p>
 <p><em>The system needs to be paused before calling this function.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Returns</dt>
+<dt class="field-odd">Returns<span class="colon">:</span></dt>
 <dd class="field-odd"><p><ul class="simple">
 <li><p>GHSReturnValue - Resume recording status.</p></li>
 </ul>
@@ -169,7 +186,7 @@ <h1>Acquisition control<a class="headerlink" href="#acquisition-control" title="
 <dd><p>Stops a started recording.</p>
 <p><em>The system needs to be recording before calling this function.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Returns</dt>
+<dt class="field-odd">Returns<span class="colon">:</span></dt>
 <dd class="field-odd"><p><ul class="simple">
 <li><p>GHSReturnValue - Stop recording status.</p></li>
 </ul>
@@ -184,7 +201,7 @@ <h1>Acquisition control<a class="headerlink" href="#acquisition-control" title="
 <dd><p>Issues a trigger.</p>
 <p>Results in error when the trigger cannot be issued.</p>
 <dl class="field-list simple">
-<dt class="field-odd">Returns</dt>
+<dt class="field-odd">Returns<span class="colon">:</span></dt>
 <dd class="field-odd"><p><ul class="simple">
 <li><p>GHSReturnValue - Trigger status.</p></li>
 </ul>
@@ -198,7 +215,7 @@ <h1>Acquisition control<a class="headerlink" href="#acquisition-control" title="
 <span class="sig-prename descclassname"><span class="pre">GHS.</span></span><span class="sig-name descname"><span class="pre">ghs_get_acquisition_state</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span> <span class="sig-return"><span class="sig-return-icon">&#x2192;</span> <span class="sig-return-typehint"><span class="pre">tuple</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">,</span></span><span class="w"> </span><span class="pre">str</span><span class="w"> </span><span class="p"><span class="pre">|</span></span><span class="w"> </span><span class="pre">None</span><span class="p"><span class="pre">]</span></span></span></span><a class="reference internal" href="_modules/ghsapi/ghsapi.html#GHS.ghs_get_acquisition_state"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#ghsapi.ghsapi.GHS.ghs_get_acquisition_state" title="Permalink to this definition"></a></dt>
 <dd><p>Returns the Acquisition State of the Mainframe.</p>
 <dl class="field-list simple">
-<dt class="field-odd">Returns</dt>
+<dt class="field-odd">Returns<span class="colon">:</span></dt>
 <dd class="field-odd"><p><ul class="simple">
 <li><p>GHSReturnValue - API return status</p></li>
 <li><p>GHSAcquisitionState - acquisition state of the mainframe.</p></li>
@@ -214,7 +231,7 @@ <h1>Acquisition control<a class="headerlink" href="#acquisition-control" title="
 <dd><p>Retrieves the current acquisition time relative to the start
 of acquistion.</p>
 <dl class="field-list simple">
-<dt class="field-odd">Returns</dt>
+<dt class="field-odd">Returns<span class="colon">:</span></dt>
 <dd class="field-odd"><p><ul class="simple">
 <li><p>GHSReturnValue - API return status</p></li>
 <li><p>acquisition_time - The acquisition time in seconds.</p></li>
@@ -229,7 +246,7 @@ <h1>Acquisition control<a class="headerlink" href="#acquisition-control" title="
 <span class="sig-prename descclassname"><span class="pre">GHS.</span></span><span class="sig-name descname"><span class="pre">ghs_get_acquisition_start_time</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span> <span class="sig-return"><span class="sig-return-icon">&#x2192;</span> <span class="sig-return-typehint"><span class="pre">tuple</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">,</span></span><span class="w"> </span><span class="pre">int</span><span class="w"> </span><span class="p"><span class="pre">|</span></span><span class="w"> </span><span class="pre">None</span><span class="p"><span class="pre">,</span></span><span class="w"> </span><span class="pre">int</span><span class="w"> </span><span class="p"><span class="pre">|</span></span><span class="w"> </span><span class="pre">None</span><span class="p"><span class="pre">,</span></span><span class="w"> </span><span class="pre">float</span><span class="w"> </span><span class="p"><span class="pre">|</span></span><span class="w"> </span><span class="pre">None</span><span class="p"><span class="pre">]</span></span></span></span><a class="reference internal" href="_modules/ghsapi/ghsapi.html#GHS.ghs_get_acquisition_start_time"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#ghsapi.ghsapi.GHS.ghs_get_acquisition_start_time" title="Permalink to this definition"></a></dt>
 <dd><p>Retrieves the absolute time of the start of acquisition.</p>
 <dl class="field-list simple">
-<dt class="field-odd">Returns</dt>
+<dt class="field-odd">Returns<span class="colon">:</span></dt>
 <dd class="field-odd"><p><ul class="simple">
 <li><p>GHSReturnValue - API return status</p></li>
 <li><p>year - The year</p></li>
diff --git a/docs/html/channel.html b/docs/html/channel.html
index 4e2b8fe..1c19301 100644
--- a/docs/html/channel.html
+++ b/docs/html/channel.html
@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html class="writer-html5" lang="en" >
 <head>
-  <meta charset="utf-8" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
+  <meta charset="utf-8" /><meta name="generator" content="Docutils 0.18.1: http://docutils.sourceforge.net/" />
 
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <title>Channel &mdash; GEN DAQ API - Python Driver 1.1 documentation</title>
@@ -11,10 +11,11 @@
     <script src="_static/js/html5shiv.min.js"></script>
   <![endif]-->
   
-        <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
         <script src="_static/jquery.js"></script>
-        <script src="_static/underscore.js"></script>
+        <script src="_static/_sphinx_javascript_frameworks_compat.js"></script>
+        <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
         <script src="_static/doctools.js"></script>
+        <script src="_static/sphinx_highlight.js"></script>
     <script src="_static/js/theme.js"></script>
     <link rel="index" title="Index" href="genindex.html" />
     <link rel="search" title="Search" href="search.html" />
@@ -27,11 +28,15 @@
     <nav data-toggle="wy-nav-shift" class="wy-nav-side">
       <div class="wy-side-scroll">
         <div class="wy-side-nav-search" >
-            <a href="index.html" class="icon icon-home"> GEN DAQ API - Python Driver
+
+          
+          
+          <a href="index.html" class="icon icon-home">
+            GEN DAQ API - Python Driver
           </a>
 <div role="search">
   <form id="rtd-search-form" class="wy-form" action="search.html" method="get">
-    <input type="text" name="q" placeholder="Search docs" />
+    <input type="text" name="q" placeholder="Search docs" aria-label="Search docs" />
     <input type="hidden" name="check_keywords" value="yes" />
     <input type="hidden" name="area" value="default" />
   </form>
@@ -68,9 +73,9 @@
         <div class="rst-content">
           <div role="navigation" aria-label="Page navigation">
   <ul class="wy-breadcrumbs">
-      <li><a href="index.html" class="icon icon-home"></a> &raquo;</li>
-          <li><a href="ghspyapi.html">API Functions</a> &raquo;</li>
-      <li>Channel</li>
+      <li><a href="index.html" class="icon icon-home" aria-label="Home"></a></li>
+          <li class="breadcrumb-item"><a href="ghspyapi.html">API Functions</a></li>
+      <li class="breadcrumb-item active">Channel</li>
       <li class="wy-breadcrumbs-aside">
             <a href="_sources/channel.rst.txt" rel="nofollow"> View page source</a>
       </li>
@@ -81,10 +86,10 @@
            <div itemprop="articleBody">
              
   <section id="channel">
-<h1>Channel<a class="headerlink" href="#channel" title="Permalink to this headline"></a></h1>
+<h1>Channel<a class="headerlink" href="#channel" title="Permalink to this heading"></a></h1>
 <p>Channel related API functions.</p>
 <section id="modules">
-<h2>Modules<a class="headerlink" href="#modules" title="Permalink to this headline"></a></h2>
+<h2>Modules<a class="headerlink" href="#modules" title="Permalink to this heading"></a></h2>
 <div class="toctree-wrapper compound">
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="channelanalog.html">Analog</a></li>
@@ -93,7 +98,7 @@ <h2>Modules<a class="headerlink" href="#modules" title="Permalink to this headli
 </div>
 </section>
 <section id="functions">
-<h2>Functions<a class="headerlink" href="#functions" title="Permalink to this headline"></a></h2>
+<h2>Functions<a class="headerlink" href="#functions" title="Permalink to this heading"></a></h2>
 <dl class="py method">
 <dt class="sig sig-object py" id="ghsapi.ghsapi.GHS.ghs_get_channel_type">
 <span class="sig-prename descclassname"><span class="pre">GHS.</span></span><span class="sig-name descname"><span class="pre">ghs_get_channel_type</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">slot_id</span></span><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="n"><span class="pre">str</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">channel_index</span></span><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="n"><span class="pre">int</span></span></em><span class="sig-paren">)</span> <span class="sig-return"><span class="sig-return-icon">&#x2192;</span> <span class="sig-return-typehint"><span class="pre">tuple</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">,</span></span><span class="w"> </span><span class="pre">int</span><span class="w"> </span><span class="p"><span class="pre">|</span></span><span class="w"> </span><span class="pre">None</span><span class="p"><span class="pre">]</span></span></span></span><a class="reference internal" href="_modules/ghsapi/ghsapi.html#GHS.ghs_get_channel_type"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#ghsapi.ghsapi.GHS.ghs_get_channel_type" title="Permalink to this definition"></a></dt>
@@ -101,13 +106,13 @@ <h2>Functions<a class="headerlink" href="#functions" title="Permalink to this he
 <p><em>Read - This method can be called by multiple connected clients at same
 time.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>channel_index</strong> – The zero-based index of the channel</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return values</p></li>
 <li><p>GHSChannelType - Type of the channel</p></li>
@@ -125,13 +130,13 @@ <h2>Functions<a class="headerlink" href="#functions" title="Permalink to this he
 <p><em>Read - This method can be called by multiple connected clients at same
 time.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>channel_index</strong> – The zero-based index of the channel</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return values</p></li>
 <li><p>channel_name - The name of the channel</p></li>
@@ -150,14 +155,14 @@ <h2>Functions<a class="headerlink" href="#functions" title="Permalink to this he
 connected client with the most privileges order (Privileges
 order: 1- Perception, 2- GenDaq, 3- Other)</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>channel_index</strong> – The zero-based index of the channel</p></li>
 <li><p><strong>channel_name</strong> – The name of the channel</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return values</p></li>
 </ul>
@@ -173,13 +178,13 @@ <h2>Functions<a class="headerlink" href="#functions" title="Permalink to this he
 <p><em>Read - This method can be called by multiple connected clients at same
 time.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>channel_index</strong> – The zero-based index of the channel</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return values</p></li>
 <li><p>GHSEnableDisable - The storage enabled status for the channel</p></li>
@@ -198,14 +203,14 @@ <h2>Functions<a class="headerlink" href="#functions" title="Permalink to this he
 connected client with the most privileges order (Privileges
 order: 1- Perception, 2- GenDaq, 3- Other)</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>channel_index</strong> – The zero-based index of the channel</p></li>
 <li><p><strong>enabled</strong> – The desired storage enabled status for the channel</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return values</p></li>
 </ul>
@@ -222,14 +227,14 @@ <h2>Functions<a class="headerlink" href="#functions" title="Permalink to this he
 <p><em>Read - This method can be called by multiple connected clients at same
 time.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>channel_index</strong> – The zero-based index of the channel</p></li>
 <li><p><strong>ezeroing</strong> – Zero / Unzero the specific channel</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return values</p></li>
 </ul>
diff --git a/docs/html/channelanalog.html b/docs/html/channelanalog.html
index a1e72f7..91c8eea 100644
--- a/docs/html/channelanalog.html
+++ b/docs/html/channelanalog.html
@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html class="writer-html5" lang="en" >
 <head>
-  <meta charset="utf-8" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
+  <meta charset="utf-8" /><meta name="generator" content="Docutils 0.18.1: http://docutils.sourceforge.net/" />
 
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <title>Analog &mdash; GEN DAQ API - Python Driver 1.1 documentation</title>
@@ -11,10 +11,11 @@
     <script src="_static/js/html5shiv.min.js"></script>
   <![endif]-->
   
-        <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
         <script src="_static/jquery.js"></script>
-        <script src="_static/underscore.js"></script>
+        <script src="_static/_sphinx_javascript_frameworks_compat.js"></script>
+        <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
         <script src="_static/doctools.js"></script>
+        <script src="_static/sphinx_highlight.js"></script>
     <script src="_static/js/theme.js"></script>
     <link rel="index" title="Index" href="genindex.html" />
     <link rel="search" title="Search" href="search.html" />
@@ -27,11 +28,15 @@
     <nav data-toggle="wy-nav-shift" class="wy-nav-side">
       <div class="wy-side-scroll">
         <div class="wy-side-nav-search" >
-            <a href="index.html" class="icon icon-home"> GEN DAQ API - Python Driver
+
+          
+          
+          <a href="index.html" class="icon icon-home">
+            GEN DAQ API - Python Driver
           </a>
 <div role="search">
   <form id="rtd-search-form" class="wy-form" action="search.html" method="get">
-    <input type="text" name="q" placeholder="Search docs" />
+    <input type="text" name="q" placeholder="Search docs" aria-label="Search docs" />
     <input type="hidden" name="check_keywords" value="yes" />
     <input type="hidden" name="area" value="default" />
   </form>
@@ -68,10 +73,10 @@
         <div class="rst-content">
           <div role="navigation" aria-label="Page navigation">
   <ul class="wy-breadcrumbs">
-      <li><a href="index.html" class="icon icon-home"></a> &raquo;</li>
-          <li><a href="ghspyapi.html">API Functions</a> &raquo;</li>
-          <li><a href="channel.html">Channel</a> &raquo;</li>
-      <li>Analog</li>
+      <li><a href="index.html" class="icon icon-home" aria-label="Home"></a></li>
+          <li class="breadcrumb-item"><a href="ghspyapi.html">API Functions</a></li>
+          <li class="breadcrumb-item"><a href="channel.html">Channel</a></li>
+      <li class="breadcrumb-item active">Analog</li>
       <li class="wy-breadcrumbs-aside">
             <a href="_sources/channelanalog.rst.txt" rel="nofollow"> View page source</a>
       </li>
@@ -82,7 +87,7 @@
            <div itemprop="articleBody">
              
   <section id="analog">
-<h1>Analog<a class="headerlink" href="#analog" title="Permalink to this headline"></a></h1>
+<h1>Analog<a class="headerlink" href="#analog" title="Permalink to this heading"></a></h1>
 <p>Analog channel related API functions.</p>
 <dl class="py method">
 <dt class="sig sig-object py" id="ghsapi.ghsapi.GHS.ghs_get_trigger_settings">
@@ -91,13 +96,13 @@ <h1>Analog<a class="headerlink" href="#analog" title="Permalink to this headline
 <p><em>Read - This method can be called by multiple connected clients at same
 time.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>channel_index</strong> – The zero-based index of the channel</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return values</p></li>
 <li><p>GHSTriggerMode - Trigger Mode</p></li>
@@ -125,7 +130,7 @@ <h1>Analog<a class="headerlink" href="#analog" title="Permalink to this headline
 connected client with the most privileges order (Privileges
 order: 1- Perception, 2- GenDaq, 3- Other)</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>channel_index</strong> – The zero-based index of the channel</p></li>
@@ -136,7 +141,7 @@ <h1>Analog<a class="headerlink" href="#analog" title="Permalink to this headline
 <li><p><strong>direction</strong> – The desired trigger direction</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return values</p></li>
 </ul>
@@ -152,13 +157,13 @@ <h1>Analog<a class="headerlink" href="#analog" title="Permalink to this headline
 <p><em>Read - This method can be called by multiple connected clients at same
 time.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>channel_index</strong> – The zero-based index of the channel</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return values</p></li>
 <li><p>GHSSignalCoupling - The signal coupling</p></li>
@@ -178,14 +183,14 @@ <h1>Analog<a class="headerlink" href="#analog" title="Permalink to this headline
 connected client with the most privileges order (Privileges
 order: 1- Perception, 2- GenDaq, 3- Other)</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>channel_index</strong> – The zero-based index of the channel</p></li>
 <li><p><strong>signal_coupling</strong> – The desired signal coupling.</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return values</p></li>
 </ul>
@@ -201,13 +206,13 @@ <h1>Analog<a class="headerlink" href="#analog" title="Permalink to this headline
 <p><em>Read - This method can be called by multiple connected clients at same
 time.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>channel_index</strong> – The zero-based index of the channel</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return values</p></li>
 <li><p>GHSInputCoupling - The input coupling</p></li>
@@ -227,14 +232,14 @@ <h1>Analog<a class="headerlink" href="#analog" title="Permalink to this headline
 connected client with the most privileges order (Privileges
 order: 1- Perception, 2- GenDaq, 3- Other)</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>channel_index</strong> – The zero-based index of the channel</p></li>
 <li><p><strong>input_coupling</strong> – The desired input coupling.</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return values</p></li>
 </ul>
@@ -250,13 +255,13 @@ <h1>Analog<a class="headerlink" href="#analog" title="Permalink to this headline
 <p><em>Read - This method can be called by multiple connected clients at same
 time.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>channel_index</strong> – The zero-based index of the channel</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return values</p></li>
 <li><p>span - The span in user units</p></li>
@@ -275,7 +280,7 @@ <h1>Analog<a class="headerlink" href="#analog" title="Permalink to this headline
 connected client with the most privileges order (Privileges
 order: 1- Perception, 2- GenDaq, 3- Other)</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>channel_index</strong> – The zero-based index of the channel</p></li>
@@ -283,7 +288,7 @@ <h1>Analog<a class="headerlink" href="#analog" title="Permalink to this headline
 <li><p><strong>offset</strong> – The offset in user units. The value is adapted to available options.</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return values</p></li>
 </ul>
@@ -299,13 +304,13 @@ <h1>Analog<a class="headerlink" href="#analog" title="Permalink to this headline
 <p><em>Read - This method can be called by multiple connected clients at same
 time.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>channel_index</strong> – The zero-based index of the channel</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return values</p></li>
 <li><p>GHSFilterType - The filter type</p></li>
@@ -329,7 +334,7 @@ <h1>Analog<a class="headerlink" href="#analog" title="Permalink to this headline
 connected client with the most privileges order (Privileges
 order: 1- Perception, 2- GenDaq, 3- Other)</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>channel_index</strong> – The zero-based index of the channel</p></li>
@@ -337,7 +342,7 @@ <h1>Analog<a class="headerlink" href="#analog" title="Permalink to this headline
 <li><p><strong>frequency</strong> – The filter frequency in Hz.</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return values</p></li>
 </ul>
@@ -353,13 +358,13 @@ <h1>Analog<a class="headerlink" href="#analog" title="Permalink to this headline
 <p><em>Read - This method can be called by multiple connected clients at same
 time.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>channel_index</strong> – The zero-based index of the channel</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return values</p></li>
 <li><p>GHSExcitationType - The excitation type</p></li>
@@ -382,7 +387,7 @@ <h1>Analog<a class="headerlink" href="#analog" title="Permalink to this headline
 connected client with the most privileges order (Privileges
 order: 1- Perception, 2- GenDaq, 3- Other)</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>channel_index</strong> – The zero-based index of the channel</p></li>
@@ -390,7 +395,7 @@ <h1>Analog<a class="headerlink" href="#analog" title="Permalink to this headline
 <li><p><strong>excitation_value</strong> – The desired excitation value in user units (voltage or current).</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return values</p></li>
 </ul>
@@ -406,13 +411,13 @@ <h1>Analog<a class="headerlink" href="#analog" title="Permalink to this headline
 <p><em>Read - This method can be called by multiple connected clients at same
 time.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>channel_index</strong> – The zero-based index of the channel</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return values</p></li>
 <li><p>GHSAmplifierMode - The amplifier mode</p></li>
@@ -433,14 +438,14 @@ <h1>Analog<a class="headerlink" href="#analog" title="Permalink to this headline
 connected client with the most privileges order (Privileges
 order: 1- Perception, 2- GenDaq, 3- Other)</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>channel_index</strong> – The zero-based index of the channel</p></li>
 <li><p><strong>amplifier_mode</strong> – The desired amplifier mode</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return values</p></li>
 </ul>
@@ -458,13 +463,13 @@ <h1>Analog<a class="headerlink" href="#analog" title="Permalink to this headline
 <p><em>Read - This method can be called by multiple connected clients at same
 time.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>channel_index</strong> – The zero-based index of the channel</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return values</p></li>
 <li><p>units - The technical units (e.g. ‘V’ for Volt or ‘Hz’ for Hertz).</p></li>
@@ -486,7 +491,7 @@ <h1>Analog<a class="headerlink" href="#analog" title="Permalink to this headline
 connected client with the most privileges order (Privileges
 order: 1- Perception, 2- GenDaq, 3- Other)</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>channel_index</strong> – The zero-based index of the channel</p></li>
@@ -495,7 +500,7 @@ <h1>Analog<a class="headerlink" href="#analog" title="Permalink to this headline
 <li><p><strong>offset</strong> – The desired technical units offset value.</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return values</p></li>
 </ul>
@@ -511,13 +516,13 @@ <h1>Analog<a class="headerlink" href="#analog" title="Permalink to this headline
 <p><em>Read - This method can be called by multiple connected clients at same
 time.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>channel_index</strong> – The zero-based index of the channel</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return values</p></li>
 <li><p>GHSEnableDisable - The auto range enabled setting.</p></li>
@@ -536,7 +541,7 @@ <h1>Analog<a class="headerlink" href="#analog" title="Permalink to this headline
 connected client with the most privileges order (Privileges
 order: 1- Perception, 2- GenDaq, 3- Other)</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>channel_index</strong> – The zero-based index of the channel</p></li>
@@ -544,7 +549,7 @@ <h1>Analog<a class="headerlink" href="#analog" title="Permalink to this headline
 <li><p><strong>auto_range_time</strong> – The time for auto range in seconds. The value is adapted to available options.</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return values</p></li>
 </ul>
@@ -563,14 +568,14 @@ <h1>Analog<a class="headerlink" href="#analog" title="Permalink to this headline
 connected client with the most privileges order (Privileges
 order: 1- Perception, 2- GenDaq, 3- Other)</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>channel_index</strong> – The zero-based index of the channel</p></li>
 <li><p><strong>auto_range_time</strong> – The time for auto range in seconds. The value is adapted to available options.</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return values</p></li>
 </ul>
@@ -589,13 +594,13 @@ <h1>Analog<a class="headerlink" href="#analog" title="Permalink to this headline
 <p><em>Read - This method can be called by multiple connected clients at same
 time.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>channel_index</strong> – The zero-based index of the channel</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return values</p></li>
 <li><p>calibration_date_time - The date and time this analog channel has been calibrated.</p></li>
diff --git a/docs/html/channeltimer.html b/docs/html/channeltimer.html
index 820b9aa..ee1290f 100644
--- a/docs/html/channeltimer.html
+++ b/docs/html/channeltimer.html
@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html class="writer-html5" lang="en" >
 <head>
-  <meta charset="utf-8" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
+  <meta charset="utf-8" /><meta name="generator" content="Docutils 0.18.1: http://docutils.sourceforge.net/" />
 
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <title>Timer/Counter &mdash; GEN DAQ API - Python Driver 1.1 documentation</title>
@@ -11,14 +11,15 @@
     <script src="_static/js/html5shiv.min.js"></script>
   <![endif]-->
   
-        <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
         <script src="_static/jquery.js"></script>
-        <script src="_static/underscore.js"></script>
+        <script src="_static/_sphinx_javascript_frameworks_compat.js"></script>
+        <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
         <script src="_static/doctools.js"></script>
+        <script src="_static/sphinx_highlight.js"></script>
     <script src="_static/js/theme.js"></script>
     <link rel="index" title="Index" href="genindex.html" />
     <link rel="search" title="Search" href="search.html" />
-    <link rel="next" title="Release Notes" href="releasenotes.html" />
+    <link rel="next" title="FieldBus" href="fieldbus.html" />
     <link rel="prev" title="Analog" href="channelanalog.html" /> 
 </head>
 
@@ -27,11 +28,15 @@
     <nav data-toggle="wy-nav-shift" class="wy-nav-side">
       <div class="wy-side-scroll">
         <div class="wy-side-nav-search" >
-            <a href="index.html" class="icon icon-home"> GEN DAQ API - Python Driver
+
+          
+          
+          <a href="index.html" class="icon icon-home">
+            GEN DAQ API - Python Driver
           </a>
 <div role="search">
   <form id="rtd-search-form" class="wy-form" action="search.html" method="get">
-    <input type="text" name="q" placeholder="Search docs" />
+    <input type="text" name="q" placeholder="Search docs" aria-label="Search docs" />
     <input type="hidden" name="check_keywords" value="yes" />
     <input type="hidden" name="area" value="default" />
   </form>
@@ -68,10 +73,10 @@
         <div class="rst-content">
           <div role="navigation" aria-label="Page navigation">
   <ul class="wy-breadcrumbs">
-      <li><a href="index.html" class="icon icon-home"></a> &raquo;</li>
-          <li><a href="ghspyapi.html">API Functions</a> &raquo;</li>
-          <li><a href="channel.html">Channel</a> &raquo;</li>
-      <li>Timer/Counter</li>
+      <li><a href="index.html" class="icon icon-home" aria-label="Home"></a></li>
+          <li class="breadcrumb-item"><a href="ghspyapi.html">API Functions</a></li>
+          <li class="breadcrumb-item"><a href="channel.html">Channel</a></li>
+      <li class="breadcrumb-item active">Timer/Counter</li>
       <li class="wy-breadcrumbs-aside">
             <a href="_sources/channeltimer.rst.txt" rel="nofollow"> View page source</a>
       </li>
@@ -82,7 +87,7 @@
            <div itemprop="articleBody">
              
   <section id="timer-counter">
-<h1>Timer/Counter<a class="headerlink" href="#timer-counter" title="Permalink to this headline"></a></h1>
+<h1>Timer/Counter<a class="headerlink" href="#timer-counter" title="Permalink to this heading"></a></h1>
 <p>Timer/Counter channel related API functions.</p>
 <dl class="py method">
 <dt class="sig sig-object py" id="ghsapi.ghsapi.GHS.ghs_get_timer_counter_gate_time">
@@ -91,13 +96,13 @@ <h1>Timer/Counter<a class="headerlink" href="#timer-counter" title="Permalink to
 <p><em>Read - This method can be called by multiple connected clients at same
 time.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>channel_index</strong> – The zero-based index of the channel</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return values</p></li>
 <li><p>gate_time - The gate time in seconds</p></li>
@@ -119,14 +124,14 @@ <h1>Timer/Counter<a class="headerlink" href="#timer-counter" title="Permalink to
 connected client with the most privileges order (Privileges
 order: 1- Perception, 2- GenDaq, 3- Other)</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>channel_index</strong> – The zero-based index of the channel</p></li>
 <li><p><strong>gate_time</strong> – The desired gate time in seconds.</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return values</p></li>
 </ul>
@@ -142,13 +147,13 @@ <h1>Timer/Counter<a class="headerlink" href="#timer-counter" title="Permalink to
 <p><em>Read - This method can be called by multiple connected clients at same
 time.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>channel_index</strong> – The zero-based index of the channel</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return values</p></li>
 <li><p>GHSTimerCounterMode - The timer/counter mode</p></li>
@@ -169,14 +174,14 @@ <h1>Timer/Counter<a class="headerlink" href="#timer-counter" title="Permalink to
 connected client with the most privileges order (Privileges
 order: 1- Perception, 2- GenDaq, 3- Other)</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>channel_index</strong> – The zero-based index of the channel</p></li>
 <li><p><strong>mode</strong> – The desired timer/counter mode. Default is RPMUniDirectional.</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return values</p></li>
 </ul>
@@ -192,13 +197,13 @@ <h1>Timer/Counter<a class="headerlink" href="#timer-counter" title="Permalink to
 <p><em>Read - This method can be called by multiple connected clients at same
 time.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>channel_index</strong> – The zero-based index of the channel</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return values</p></li>
 <li><p>lower_value - The lower range value.</p></li>
@@ -221,7 +226,7 @@ <h1>Timer/Counter<a class="headerlink" href="#timer-counter" title="Permalink to
 connected client with the most privileges order (Privileges
 order: 1- Perception, 2- GenDaq, 3- Other)</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>channel_index</strong> – The zero-based index of the channel</p></li>
@@ -229,7 +234,7 @@ <h1>Timer/Counter<a class="headerlink" href="#timer-counter" title="Permalink to
 <li><p><strong>upper_value</strong> – The desired upper range value.</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return values</p></li>
 </ul>
@@ -250,7 +255,7 @@ <h1>Timer/Counter<a class="headerlink" href="#timer-counter" title="Permalink to
           </div>
           <footer><div class="rst-footer-buttons" role="navigation" aria-label="Footer">
         <a href="channelanalog.html" class="btn btn-neutral float-left" title="Analog" accesskey="p" rel="prev"><span class="fa fa-arrow-circle-left" aria-hidden="true"></span> Previous</a>
-        <a href="releasenotes.html" class="btn btn-neutral float-right" title="Release Notes" accesskey="n" rel="next">Next <span class="fa fa-arrow-circle-right" aria-hidden="true"></span></a>
+        <a href="fieldbus.html" class="btn btn-neutral float-right" title="FieldBus" accesskey="n" rel="next">Next <span class="fa fa-arrow-circle-right" aria-hidden="true"></span></a>
     </div>
 
   <hr/>
diff --git a/docs/html/connections.html b/docs/html/connections.html
index f68d69e..4841820 100644
--- a/docs/html/connections.html
+++ b/docs/html/connections.html
@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html class="writer-html5" lang="en" >
 <head>
-  <meta charset="utf-8" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
+  <meta charset="utf-8" /><meta name="generator" content="Docutils 0.18.1: http://docutils.sourceforge.net/" />
 
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <title>Connections &mdash; GEN DAQ API - Python Driver 1.1 documentation</title>
@@ -11,10 +11,11 @@
     <script src="_static/js/html5shiv.min.js"></script>
   <![endif]-->
   
-        <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
         <script src="_static/jquery.js"></script>
-        <script src="_static/underscore.js"></script>
+        <script src="_static/_sphinx_javascript_frameworks_compat.js"></script>
+        <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
         <script src="_static/doctools.js"></script>
+        <script src="_static/sphinx_highlight.js"></script>
     <script src="_static/js/theme.js"></script>
     <link rel="index" title="Index" href="genindex.html" />
     <link rel="search" title="Search" href="search.html" />
@@ -27,11 +28,15 @@
     <nav data-toggle="wy-nav-shift" class="wy-nav-side">
       <div class="wy-side-scroll">
         <div class="wy-side-nav-search" >
-            <a href="index.html" class="icon icon-home"> GEN DAQ API - Python Driver
+
+          
+          
+          <a href="index.html" class="icon icon-home">
+            GEN DAQ API - Python Driver
           </a>
 <div role="search">
   <form id="rtd-search-form" class="wy-form" action="search.html" method="get">
-    <input type="text" name="q" placeholder="Search docs" />
+    <input type="text" name="q" placeholder="Search docs" aria-label="Search docs" />
     <input type="hidden" name="check_keywords" value="yes" />
     <input type="hidden" name="area" value="default" />
   </form>
@@ -42,7 +47,13 @@
 <li class="toctree-l1"><a class="reference internal" href="ghspyapi.html">API Functions</a></li>
 <li class="toctree-l1 current"><a class="reference internal" href="releasenotes.html">Release Notes</a><ul class="current">
 <li class="toctree-l2 current"><a class="reference internal" href="releasenotes.html#version-1-0">Version 1.0</a><ul class="current">
-<li class="toctree-l3 current"><a class="current reference internal" href="#">Connections</a></li>
+<li class="toctree-l3 current"><a class="current reference internal" href="#">Connections</a><ul>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_connect"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_connect()</span></code></a></li>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_disconnect"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_disconnect()</span></code></a></li>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_get_client_api_version"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_client_api_version()</span></code></a></li>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_get_current_access"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_current_access()</span></code></a></li>
+</ul>
+</li>
 <li class="toctree-l3"><a class="reference internal" href="acquisition.html">Acquisition control</a></li>
 <li class="toctree-l3"><a class="reference internal" href="mainframe.html">Mainframe</a></li>
 <li class="toctree-l3"><a class="reference internal" href="managerecording.html">Manage recordings</a></li>
@@ -69,9 +80,9 @@
         <div class="rst-content">
           <div role="navigation" aria-label="Page navigation">
   <ul class="wy-breadcrumbs">
-      <li><a href="index.html" class="icon icon-home"></a> &raquo;</li>
-          <li><a href="ghspyapi.html">API Functions</a> &raquo;</li>
-      <li>Connections</li>
+      <li><a href="index.html" class="icon icon-home" aria-label="Home"></a></li>
+          <li class="breadcrumb-item"><a href="ghspyapi.html">API Functions</a></li>
+      <li class="breadcrumb-item active">Connections</li>
       <li class="wy-breadcrumbs-aside">
             <a href="_sources/connections.rst.txt" rel="nofollow"> View page source</a>
       </li>
@@ -82,20 +93,20 @@
            <div itemprop="articleBody">
              
   <section id="connections">
-<h1>Connections<a class="headerlink" href="#connections" title="Permalink to this headline"></a></h1>
+<h1>Connections<a class="headerlink" href="#connections" title="Permalink to this heading"></a></h1>
 <p>Connection related API functions.</p>
 <dl class="py method">
 <dt class="sig sig-object py" id="ghsapi.ghsapi.GHS.ghs_connect">
 <span class="sig-prename descclassname"><span class="pre">GHS.</span></span><span class="sig-name descname"><span class="pre">ghs_connect</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">ip_address</span></span><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="n"><span class="pre">int</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">port_num</span></span><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="n"><span class="pre">int</span></span></em><span class="sig-paren">)</span> <span class="sig-return"><span class="sig-return-icon">&#x2192;</span> <span class="sig-return-typehint"><span class="pre">str</span></span></span><a class="reference internal" href="_modules/ghsapi/ghsapi.html#GHS.ghs_connect"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#ghsapi.ghsapi.GHS.ghs_connect" title="Permalink to this definition"></a></dt>
 <dd><p>Establishes a connection to the mainframe.</p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>ip_address</strong> – IP address needs to be an IPV4 address.</p></li>
 <li><p><strong>port_num</strong> – TCP port number (currently defined as 8006).</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - Connect return status.</p></li>
 </ul>
@@ -111,7 +122,7 @@ <h1>Connections<a class="headerlink" href="#connections" title="Permalink to thi
 <p><em>Results in error when the handle is not valid and / or
 mainframe is not connected.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Returns</dt>
+<dt class="field-odd">Returns<span class="colon">:</span></dt>
 <dd class="field-odd"><p><ul class="simple">
 <li><p>GHSReturnValue - Disconnect return status.</p></li>
 </ul>
@@ -127,7 +138,7 @@ <h1>Connections<a class="headerlink" href="#connections" title="Permalink to thi
 <p><em>This function can be useful when ghs_connect() returns
 GHSReturnValue_APIMismatch.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Returns</dt>
+<dt class="field-odd">Returns<span class="colon">:</span></dt>
 <dd class="field-odd"><p><ul class="simple">
 <li><p>CLIENT_API_VERSION - Version number of the client.</p></li>
 </ul>
@@ -149,7 +160,7 @@ <h1>Connections<a class="headerlink" href="#connections" title="Permalink to thi
 WriteAccessBlocked in case this client currently has no write
 access.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Returns</dt>
+<dt class="field-odd">Returns<span class="colon">:</span></dt>
 <dd class="field-odd"><p><ul class="simple">
 <li><p>GHSAccess - Access permission.</p></li>
 </ul>
diff --git a/docs/html/fieldbus.html b/docs/html/fieldbus.html
new file mode 100644
index 0000000..db3fafe
--- /dev/null
+++ b/docs/html/fieldbus.html
@@ -0,0 +1,278 @@
+<!DOCTYPE html>
+<html class="writer-html5" lang="en" >
+<head>
+  <meta charset="utf-8" /><meta name="generator" content="Docutils 0.18.1: http://docutils.sourceforge.net/" />
+
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>FieldBus &mdash; GEN DAQ API - Python Driver 1.1 documentation</title>
+      <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+      <link rel="stylesheet" href="_static/css/theme.css" type="text/css" />
+  <!--[if lt IE 9]>
+    <script src="_static/js/html5shiv.min.js"></script>
+  <![endif]-->
+  
+        <script src="_static/jquery.js"></script>
+        <script src="_static/_sphinx_javascript_frameworks_compat.js"></script>
+        <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
+        <script src="_static/doctools.js"></script>
+        <script src="_static/sphinx_highlight.js"></script>
+    <script src="_static/js/theme.js"></script>
+    <link rel="index" title="Index" href="genindex.html" />
+    <link rel="search" title="Search" href="search.html" />
+    <link rel="next" title="Release Notes" href="releasenotes.html" />
+    <link rel="prev" title="Timer/Counter" href="channeltimer.html" /> 
+</head>
+
+<body class="wy-body-for-nav"> 
+  <div class="wy-grid-for-nav">
+    <nav data-toggle="wy-nav-shift" class="wy-nav-side">
+      <div class="wy-side-scroll">
+        <div class="wy-side-nav-search" >
+
+          
+          
+          <a href="index.html" class="icon icon-home">
+            GEN DAQ API - Python Driver
+          </a>
+<div role="search">
+  <form id="rtd-search-form" class="wy-form" action="search.html" method="get">
+    <input type="text" name="q" placeholder="Search docs" aria-label="Search docs" />
+    <input type="hidden" name="check_keywords" value="yes" />
+    <input type="hidden" name="area" value="default" />
+  </form>
+</div>
+        </div><div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="Navigation menu">
+              <ul class="current">
+<li class="toctree-l1"><a class="reference internal" href="introduction.html">Introduction</a></li>
+<li class="toctree-l1 current"><a class="reference internal" href="ghspyapi.html">API Functions</a><ul class="current">
+<li class="toctree-l2"><a class="reference internal" href="connections.html">Connections</a></li>
+<li class="toctree-l2"><a class="reference internal" href="acquisition.html">Acquisition control</a></li>
+<li class="toctree-l2"><a class="reference internal" href="mainframe.html">Mainframe</a></li>
+<li class="toctree-l2"><a class="reference internal" href="managerecording.html">Manage recordings</a></li>
+<li class="toctree-l2"><a class="reference internal" href="managemainframe.html">Manage mainframe settings</a></li>
+<li class="toctree-l2"><a class="reference internal" href="recorder.html">Recorder</a></li>
+<li class="toctree-l2"><a class="reference internal" href="channel.html">Channel</a></li>
+<li class="toctree-l2 current"><a class="current reference internal" href="#">FieldBus</a><ul>
+<li class="toctree-l3"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_get_fieldbus_data_count"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_fieldbus_data_count()</span></code></a></li>
+<li class="toctree-l3"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_get_fieldbus_data_name_and_unit"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_fieldbus_data_name_and_unit()</span></code></a></li>
+<li class="toctree-l3"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_initiate_fieldbus_data_transfer"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_initiate_fieldbus_data_transfer()</span></code></a></li>
+<li class="toctree-l3"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_stop_fieldbus_data_transfer"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_stop_fieldbus_data_transfer()</span></code></a></li>
+<li class="toctree-l3"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_receive_fieldbus_data"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_receive_fieldbus_data()</span></code></a></li>
+<li class="toctree-l3"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_read_next_snapshot"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_read_next_snapshot()</span></code></a></li>
+<li class="toctree-l3"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_request_fieldbus_snapshot"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_request_fieldbus_snapshot()</span></code></a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="releasenotes.html">Release Notes</a></li>
+<li class="toctree-l1"><a class="reference internal" href="remarks.html">Remarks</a></li>
+</ul>
+
+        </div>
+      </div>
+    </nav>
+
+    <section data-toggle="wy-nav-shift" class="wy-nav-content-wrap"><nav class="wy-nav-top" aria-label="Mobile navigation menu" >
+          <i data-toggle="wy-nav-top" class="fa fa-bars"></i>
+          <a href="index.html">GEN DAQ API - Python Driver</a>
+      </nav>
+
+      <div class="wy-nav-content">
+        <div class="rst-content">
+          <div role="navigation" aria-label="Page navigation">
+  <ul class="wy-breadcrumbs">
+      <li><a href="index.html" class="icon icon-home" aria-label="Home"></a></li>
+          <li class="breadcrumb-item"><a href="ghspyapi.html">API Functions</a></li>
+      <li class="breadcrumb-item active">FieldBus</li>
+      <li class="wy-breadcrumbs-aside">
+            <a href="_sources/fieldbus.rst.txt" rel="nofollow"> View page source</a>
+      </li>
+  </ul>
+  <hr/>
+</div>
+          <div role="main" class="document" itemscope="itemscope" itemtype="http://schema.org/Article">
+           <div itemprop="articleBody">
+             
+  <section id="fieldbus">
+<h1>FieldBus<a class="headerlink" href="#fieldbus" title="Permalink to this heading"></a></h1>
+<p>FieldBus related API functions.</p>
+<dl class="py method">
+<dt class="sig sig-object py" id="ghsapi.ghsapi.GHS.ghs_get_fieldbus_data_count">
+<span class="sig-prename descclassname"><span class="pre">GHS.</span></span><span class="sig-name descname"><span class="pre">ghs_get_fieldbus_data_count</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span> <span class="sig-return"><span class="sig-return-icon">&#x2192;</span> <span class="sig-return-typehint"><span class="pre">tuple</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">,</span></span><span class="w"> </span><span class="pre">int</span><span class="w"> </span><span class="p"><span class="pre">|</span></span><span class="w"> </span><span class="pre">None</span><span class="p"><span class="pre">]</span></span></span></span><a class="reference internal" href="_modules/ghsapi/ghsapi.html#GHS.ghs_get_fieldbus_data_count"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#ghsapi.ghsapi.GHS.ghs_get_fieldbus_data_count" title="Permalink to this definition"></a></dt>
+<dd><p>Gets the number of data that are configured to be sent through the field bus, excluding the timestamp.</p>
+<dl class="field-list simple">
+<dt class="field-odd">Returns<span class="colon">:</span></dt>
+<dd class="field-odd"><p><ul class="simple">
+<li><p>GHSReturnValue - API return values</p></li>
+<li><p>data_count - The number of data that are selected to be published, excluding timestamp.</p></li>
+</ul>
+</p>
+</dd>
+</dl>
+</dd></dl>
+
+<dl class="py method">
+<dt class="sig sig-object py" id="ghsapi.ghsapi.GHS.ghs_get_fieldbus_data_name_and_unit">
+<span class="sig-prename descclassname"><span class="pre">GHS.</span></span><span class="sig-name descname"><span class="pre">ghs_get_fieldbus_data_name_and_unit</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">data_index</span></span><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="n"><span class="pre">int</span></span></em><span class="sig-paren">)</span> <span class="sig-return"><span class="sig-return-icon">&#x2192;</span> <span class="sig-return-typehint"><span class="pre">tuple</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">,</span></span><span class="w"> </span><span class="pre">str</span><span class="w"> </span><span class="p"><span class="pre">|</span></span><span class="w"> </span><span class="pre">None</span><span class="p"><span class="pre">,</span></span><span class="w"> </span><span class="pre">str</span><span class="w"> </span><span class="p"><span class="pre">|</span></span><span class="w"> </span><span class="pre">None</span><span class="p"><span class="pre">]</span></span></span></span><a class="reference internal" href="_modules/ghsapi/ghsapi.html#GHS.ghs_get_fieldbus_data_name_and_unit"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#ghsapi.ghsapi.GHS.ghs_get_fieldbus_data_name_and_unit" title="Permalink to this definition"></a></dt>
+<dd><p><em>Gets the name of specific field bus data value, by giving the index of the data value.
+The number of data values can be retrieved by GHSGetFieldBusDataCount().</em></p>
+<p><em>In case of no formulas (or reserved values acquisition state and latency) published,
+an error code is returned: GHSReturnValue_FieldBusError_NoFormulasDeployed.</em></p>
+<dl class="field-list simple">
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
+<dd class="field-odd"><p><strong>data_index</strong> – Zero-based index of the data value.</p>
+</dd>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
+<dd class="field-even"><p><ul class="simple">
+<li><p>GHSReturnValue - API return values</p></li>
+<li><p>data_name - Name of the data value.</p></li>
+<li><p>data_unit - Unit of the data value.</p></li>
+</ul>
+</p>
+</dd>
+</dl>
+</dd></dl>
+
+<dl class="py method">
+<dt class="sig sig-object py" id="ghsapi.ghsapi.GHS.ghs_initiate_fieldbus_data_transfer">
+<span class="sig-prename descclassname"><span class="pre">GHS.</span></span><span class="sig-name descname"><span class="pre">ghs_initiate_fieldbus_data_transfer</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">update_rate</span></span><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="n"><span class="pre">int</span></span></em><span class="sig-paren">)</span> <span class="sig-return"><span class="sig-return-icon">&#x2192;</span> <span class="sig-return-typehint"><span class="pre">tuple</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">,</span></span><span class="w"> </span><span class="pre">int</span><span class="w"> </span><span class="p"><span class="pre">|</span></span><span class="w"> </span><span class="pre">None</span><span class="p"><span class="pre">,</span></span><span class="w"> </span><span class="pre">int</span><span class="w"> </span><span class="p"><span class="pre">|</span></span><span class="w"> </span><span class="pre">None</span><span class="p"><span class="pre">]</span></span></span></span><a class="reference internal" href="_modules/ghsapi/ghsapi.html#GHS.ghs_initiate_fieldbus_data_transfer"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#ghsapi.ghsapi.GHS.ghs_initiate_fieldbus_data_transfer" title="Permalink to this definition"></a></dt>
+<dd><p><em>Opens a new connection for the field bus data, and waits for client
+to connect. Once the client connects, if the acquisition state is
+active, data is sent to the client. Otherwise nothing is sent.</em></p>
+<p><em>If no formulas are present then you get error code back:GHSReturnValue_FieldBusError_NotConfigured</em></p>
+<p><em>If the field bus is already initiated then an error code is returned:
+GHSReturnValue_FieldBusError_FieldBusEnabled.</em></p>
+<p><em>To change the update rate the field bus needs to be stoped and inititated again with a new update rate.</em></p>
+<dl class="field-list simple">
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
+<dd class="field-odd"><ul class="simple">
+<li><p><strong>update_rate</strong> – (in Hz) The update rate should be a part of the list</p></li>
+<li><p><strong>rates</strong> (<em>containing the supported update</em>) – </p></li>
+</ul>
+</dd>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
+<dd class="field-even"><p><ul class="simple">
+<li><p>GHSReturnValue - API return values</p></li>
+<li><p>update_rate - If the update rate selected by the user is not supported, the mainframe will adjust the update rate based on a minimum distance from the supported rates and returns back to the client.</p></li>
+<li><p>data_count - The number of published data on the setup. Timestamp is not included in this count.</p></li>
+</ul>
+</p>
+</dd>
+</dl>
+</dd></dl>
+
+<dl class="py method">
+<dt class="sig sig-object py" id="ghsapi.ghsapi.GHS.ghs_stop_fieldbus_data_transfer">
+<span class="sig-prename descclassname"><span class="pre">GHS.</span></span><span class="sig-name descname"><span class="pre">ghs_stop_fieldbus_data_transfer</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span> <span class="sig-return"><span class="sig-return-icon">&#x2192;</span> <span class="sig-return-typehint"><span class="pre">str</span></span></span><a class="reference internal" href="_modules/ghsapi/ghsapi.html#GHS.ghs_stop_fieldbus_data_transfer"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#ghsapi.ghsapi.GHS.ghs_stop_fieldbus_data_transfer" title="Permalink to this definition"></a></dt>
+<dd><p><em>Closes the socket dedicated for the field bus data and stops transfering data.
+The ring buffer allocated for the transfer data is deleted.</em></p>
+<p><em>Field bus data transfer must have been initiated before calling this function</em></p>
+<dl class="field-list simple">
+<dt class="field-odd">Returns<span class="colon">:</span></dt>
+<dd class="field-odd"><p><ul class="simple">
+<li><p>GHSReturnValue - API return values</p></li>
+</ul>
+</p>
+</dd>
+</dl>
+</dd></dl>
+
+<dl class="py method">
+<dt class="sig sig-object py" id="ghsapi.ghsapi.GHS.ghs_receive_fieldbus_data">
+<span class="sig-prename descclassname"><span class="pre">GHS.</span></span><span class="sig-name descname"><span class="pre">ghs_receive_fieldbus_data</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span> <span class="sig-return"><span class="sig-return-icon">&#x2192;</span> <span class="sig-return-typehint"><span class="pre">str</span></span></span><a class="reference internal" href="_modules/ghsapi/ghsapi.html#GHS.ghs_receive_fieldbus_data"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#ghsapi.ghsapi.GHS.ghs_receive_fieldbus_data" title="Permalink to this definition"></a></dt>
+<dd><p>Used to retrieve the FieldBus data from the new socket connection and write on the buffer.</p>
+<p><em>Can be used in a thread and if so, mutual exclusion should be used with GHSStopFieldBusDataTransfer.</em></p>
+<p><em>This function should be used in a loop if continuous delivery of Async Data is desired.</em></p>
+<p><em>Field bus data transfer must have been initiated before calling this function.</em></p>
+<dl class="field-list simple">
+<dt class="field-odd">Returns<span class="colon">:</span></dt>
+<dd class="field-odd"><p><ul class="simple">
+<li><p>GHSReturnValue - API return values</p></li>
+</ul>
+</p>
+</dd>
+</dl>
+</dd></dl>
+
+<dl class="py method">
+<dt class="sig sig-object py" id="ghsapi.ghsapi.GHS.ghs_read_next_snapshot">
+<span class="sig-prename descclassname"><span class="pre">GHS.</span></span><span class="sig-name descname"><span class="pre">ghs_read_next_snapshot</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">call_type</span></span><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="n"><span class="pre">str</span><span class="w"> </span><span class="p"><span class="pre">|</span></span><span class="w"> </span><span class="pre">int</span></span></em><span class="sig-paren">)</span> <span class="sig-return"><span class="sig-return-icon">&#x2192;</span> <span class="sig-return-typehint"><span class="pre">tuple</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">,</span></span><span class="w"> </span><span class="pre">float</span><span class="w"> </span><span class="p"><span class="pre">|</span></span><span class="w"> </span><span class="pre">None</span><span class="p"><span class="pre">,</span></span><span class="w"> </span><span class="pre">float</span><span class="w"> </span><span class="p"><span class="pre">|</span></span><span class="w"> </span><span class="pre">None</span><span class="p"><span class="pre">,</span></span><span class="w"> </span><span class="pre">int</span><span class="w"> </span><span class="p"><span class="pre">|</span></span><span class="w"> </span><span class="pre">None</span><span class="p"><span class="pre">]</span></span></span></span><a class="reference internal" href="_modules/ghsapi/ghsapi.html#GHS.ghs_read_next_snapshot"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#ghsapi.ghsapi.GHS.ghs_read_next_snapshot" title="Permalink to this definition"></a></dt>
+<dd><p>Retrieves the next snapshot in the buffer.</p>
+<p><em>The timestamp is grid aligned - as specified by the ‘updateRate’ argument
+of the GHSInitiateFieldBusDataTransfer() method.</em></p>
+<dl class="field-list simple">
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
+<dd class="field-odd"><p><strong>call_type</strong> – flag to control the receiving of FieldBus data:
+<em>If set to GHS_BlockingCall it blocks while waiting for new FieldBus data.
+*If set to GHS_NonBlockingCall then returns last FieldBus data when no new data available.
+*GHS_BlockingCall is the preferred value as this results in the lowest CPU load
+and highest data troughput.</em></p>
+</dd>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
+<dd class="field-even"><p><ul class="simple">
+<li><p>GHSReturnValue - API return values</p></li>
+<li><p>Timestamp - timestamp of the FieldBus data relative to start of acquisition GHSGetAcquisitionStartTime()</p></li>
+<li><p>Values - the values published on the FieldBus.</p></li>
+<li><p>Overrun - is one if overrun happened in the buffer, zero if not.</p></li>
+</ul>
+</p>
+</dd>
+</dl>
+</dd></dl>
+
+<dl class="py method">
+<dt class="sig sig-object py" id="ghsapi.ghsapi.GHS.ghs_request_fieldbus_snapshot">
+<span class="sig-prename descclassname"><span class="pre">GHS.</span></span><span class="sig-name descname"><span class="pre">ghs_request_fieldbus_snapshot</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">dataCount</span></span><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="n"><span class="pre">int</span></span></em><span class="sig-paren">)</span> <span class="sig-return"><span class="sig-return-icon">&#x2192;</span> <span class="sig-return-typehint"><span class="pre">tuple</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">,</span></span><span class="w"> </span><span class="pre">float</span><span class="w"> </span><span class="p"><span class="pre">|</span></span><span class="w"> </span><span class="pre">None</span><span class="p"><span class="pre">,</span></span><span class="w"> </span><span class="pre">int</span><span class="w"> </span><span class="p"><span class="pre">|</span></span><span class="w"> </span><span class="pre">None</span><span class="p"><span class="pre">,</span></span><span class="w"> </span><span class="pre">tuple</span><span class="p"><span class="pre">[</span></span><span class="pre">float</span><span class="p"><span class="pre">]</span></span><span class="w"> </span><span class="p"><span class="pre">|</span></span><span class="w"> </span><span class="pre">None</span><span class="p"><span class="pre">]</span></span></span></span><a class="reference internal" href="_modules/ghsapi/ghsapi.html#GHS.ghs_request_fieldbus_snapshot"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#ghsapi.ghsapi.GHS.ghs_request_fieldbus_snapshot" title="Permalink to this definition"></a></dt>
+<dd><p><em>Request a single snapshot of the field bus data.
+In this case the timestamp received is not grid aligned.</em></p>
+<p><em>If the system is not acquiring the method returns an error code:GHSReturnValue_SystemNotRecording</em></p>
+<p><em>In case of no formulas you get the error return code back:GHSReturnValue_FieldBusError_NotConfigured</em></p>
+<p><em>If the field bus is already enabled then this method is not allowed.
+An error return code is returned:FieldBusError_UnavailableFunctionality.</em></p>
+<dl class="field-list simple">
+<dt class="field-odd">Returns<span class="colon">:</span></dt>
+<dd class="field-odd"><p><ul class="simple">
+<li><p>GHSReturnValue - API return values</p></li>
+<li><p>timestamp - Timestamp of the FieldBus data relative to start of acquisition (not grid aligned) GHSGetAcquisitionStartTime</p></li>
+<li><p>data_count - Actual number of elements(formulas) in the data parameter. If number of elements allocated by the customer are less than the actual formulas number, then we return an error code.</p></li>
+<li><p>data - Array of floats that contains the data</p></li>
+</ul>
+</p>
+</dd>
+</dl>
+</dd></dl>
+
+</section>
+
+
+           </div>
+          </div>
+          <footer><div class="rst-footer-buttons" role="navigation" aria-label="Footer">
+        <a href="channeltimer.html" class="btn btn-neutral float-left" title="Timer/Counter" accesskey="p" rel="prev"><span class="fa fa-arrow-circle-left" aria-hidden="true"></span> Previous</a>
+        <a href="releasenotes.html" class="btn btn-neutral float-right" title="Release Notes" accesskey="n" rel="next">Next <span class="fa fa-arrow-circle-right" aria-hidden="true"></span></a>
+    </div>
+
+  <hr/>
+
+  <div role="contentinfo">
+    <p>&#169; Copyright 2022, Hottinger Bruel and Kjaer Benelux B.V..</p>
+  </div>
+
+  Built with <a href="https://www.sphinx-doc.org/">Sphinx</a> using a
+    <a href="https://github.com/readthedocs/sphinx_rtd_theme">theme</a>
+    provided by <a href="https://readthedocs.org">Read the Docs</a>.
+   
+
+</footer>
+        </div>
+      </div>
+    </section>
+  </div>
+  <script>
+      jQuery(function () {
+          SphinxRtdTheme.Navigation.enable(true);
+      });
+  </script> 
+
+</body>
+</html>
\ No newline at end of file
diff --git a/docs/html/genindex.html b/docs/html/genindex.html
index f6804e6..1171cc2 100644
--- a/docs/html/genindex.html
+++ b/docs/html/genindex.html
@@ -10,10 +10,11 @@
     <script src="_static/js/html5shiv.min.js"></script>
   <![endif]-->
   
-        <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
         <script src="_static/jquery.js"></script>
-        <script src="_static/underscore.js"></script>
+        <script src="_static/_sphinx_javascript_frameworks_compat.js"></script>
+        <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
         <script src="_static/doctools.js"></script>
+        <script src="_static/sphinx_highlight.js"></script>
     <script src="_static/js/theme.js"></script>
     <link rel="index" title="Index" href="#" />
     <link rel="search" title="Search" href="search.html" /> 
@@ -24,11 +25,15 @@
     <nav data-toggle="wy-nav-shift" class="wy-nav-side">
       <div class="wy-side-scroll">
         <div class="wy-side-nav-search" >
-            <a href="index.html" class="icon icon-home"> GEN DAQ API - Python Driver
+
+          
+          
+          <a href="index.html" class="icon icon-home">
+            GEN DAQ API - Python Driver
           </a>
 <div role="search">
   <form id="rtd-search-form" class="wy-form" action="search.html" method="get">
-    <input type="text" name="q" placeholder="Search docs" />
+    <input type="text" name="q" placeholder="Search docs" aria-label="Search docs" />
     <input type="hidden" name="check_keywords" value="yes" />
     <input type="hidden" name="area" value="default" />
   </form>
@@ -54,8 +59,8 @@
         <div class="rst-content">
           <div role="navigation" aria-label="Page navigation">
   <ul class="wy-breadcrumbs">
-      <li><a href="index.html" class="icon icon-home"></a> &raquo;</li>
-      <li>Index</li>
+      <li><a href="index.html" class="icon icon-home" aria-label="Home"></a></li>
+      <li class="breadcrumb-item active">Index</li>
       <li class="wy-breadcrumbs-aside">
       </li>
   </ul>
@@ -119,6 +124,10 @@ <h2 id="G">G</h2>
       <li><a href="mainframe.html#ghsapi.ghsapi.GHS.ghs_get_disk_space">ghs_get_disk_space() (ghsapi.ghsapi.GHS method)</a>
 </li>
       <li><a href="channelanalog.html#ghsapi.ghsapi.GHS.ghs_get_excitation">ghs_get_excitation() (ghsapi.ghsapi.GHS method)</a>
+</li>
+      <li><a href="fieldbus.html#ghsapi.ghsapi.GHS.ghs_get_fieldbus_data_count">ghs_get_fieldbus_data_count() (ghsapi.ghsapi.GHS method)</a>
+</li>
+      <li><a href="fieldbus.html#ghsapi.ghsapi.GHS.ghs_get_fieldbus_data_name_and_unit">ghs_get_fieldbus_data_name_and_unit() (ghsapi.ghsapi.GHS method)</a>
 </li>
       <li><a href="channelanalog.html#ghsapi.ghsapi.GHS.ghs_get_filter_type_and_frequency">ghs_get_filter_type_and_frequency() (ghsapi.ghsapi.GHS method)</a>
 </li>
@@ -146,12 +155,12 @@ <h2 id="G">G</h2>
 </li>
       <li><a href="mainframe.html#ghsapi.ghsapi.GHS.ghs_get_sync_status">ghs_get_sync_status() (ghsapi.ghsapi.GHS method)</a>
 </li>
-  </ul></td>
-  <td style="width: 33%; vertical-align: top;"><ul>
       <li><a href="channelanalog.html#ghsapi.ghsapi.GHS.ghs_get_technical_units">ghs_get_technical_units() (ghsapi.ghsapi.GHS method)</a>
 </li>
       <li><a href="channeltimer.html#ghsapi.ghsapi.GHS.ghs_get_timer_counter_gate_time">ghs_get_timer_counter_gate_time() (ghsapi.ghsapi.GHS method)</a>
 </li>
+  </ul></td>
+  <td style="width: 33%; vertical-align: top;"><ul>
       <li><a href="channeltimer.html#ghsapi.ghsapi.GHS.ghs_get_timer_counter_mode">ghs_get_timer_counter_mode() (ghsapi.ghsapi.GHS method)</a>
 </li>
       <li><a href="channeltimer.html#ghsapi.ghsapi.GHS.ghs_get_timer_counter_range">ghs_get_timer_counter_range() (ghsapi.ghsapi.GHS method)</a>
@@ -161,10 +170,18 @@ <h2 id="G">G</h2>
       <li><a href="mainframe.html#ghsapi.ghsapi.GHS.ghs_get_user_mode">ghs_get_user_mode() (ghsapi.ghsapi.GHS method)</a>
 </li>
       <li><a href="mainframe.html#ghsapi.ghsapi.GHS.ghs_identify">ghs_identify() (ghsapi.ghsapi.GHS method)</a>
+</li>
+      <li><a href="fieldbus.html#ghsapi.ghsapi.GHS.ghs_initiate_fieldbus_data_transfer">ghs_initiate_fieldbus_data_transfer() (ghsapi.ghsapi.GHS method)</a>
 </li>
       <li><a href="acquisition.html#ghsapi.ghsapi.GHS.ghs_pause_recording">ghs_pause_recording() (ghsapi.ghsapi.GHS method)</a>
 </li>
       <li><a href="managemainframe.html#ghsapi.ghsapi.GHS.ghs_persist_current_settings">ghs_persist_current_settings() (ghsapi.ghsapi.GHS method)</a>
+</li>
+      <li><a href="fieldbus.html#ghsapi.ghsapi.GHS.ghs_read_next_snapshot">ghs_read_next_snapshot() (ghsapi.ghsapi.GHS method)</a>
+</li>
+      <li><a href="fieldbus.html#ghsapi.ghsapi.GHS.ghs_receive_fieldbus_data">ghs_receive_fieldbus_data() (ghsapi.ghsapi.GHS method)</a>
+</li>
+      <li><a href="fieldbus.html#ghsapi.ghsapi.GHS.ghs_request_fieldbus_snapshot">ghs_request_fieldbus_snapshot() (ghsapi.ghsapi.GHS method)</a>
 </li>
       <li><a href="acquisition.html#ghsapi.ghsapi.GHS.ghs_resume_recording">ghs_resume_recording() (ghsapi.ghsapi.GHS method)</a>
 </li>
@@ -215,6 +232,8 @@ <h2 id="G">G</h2>
       <li><a href="acquisition.html#ghsapi.ghsapi.GHS.ghs_start_preview">ghs_start_preview() (ghsapi.ghsapi.GHS method)</a>
 </li>
       <li><a href="acquisition.html#ghsapi.ghsapi.GHS.ghs_start_recording">ghs_start_recording() (ghsapi.ghsapi.GHS method)</a>
+</li>
+      <li><a href="fieldbus.html#ghsapi.ghsapi.GHS.ghs_stop_fieldbus_data_transfer">ghs_stop_fieldbus_data_transfer() (ghsapi.ghsapi.GHS method)</a>
 </li>
       <li><a href="acquisition.html#ghsapi.ghsapi.GHS.ghs_stop_preview">ghs_stop_preview() (ghsapi.ghsapi.GHS method)</a>
 </li>
diff --git a/docs/html/ghspyapi.html b/docs/html/ghspyapi.html
index 0421c2e..24dc636 100644
--- a/docs/html/ghspyapi.html
+++ b/docs/html/ghspyapi.html
@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html class="writer-html5" lang="en" >
 <head>
-  <meta charset="utf-8" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
+  <meta charset="utf-8" /><meta name="generator" content="Docutils 0.18.1: http://docutils.sourceforge.net/" />
 
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <title>API Functions &mdash; GEN DAQ API - Python Driver 1.1 documentation</title>
@@ -11,10 +11,11 @@
     <script src="_static/js/html5shiv.min.js"></script>
   <![endif]-->
   
-        <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
         <script src="_static/jquery.js"></script>
-        <script src="_static/underscore.js"></script>
+        <script src="_static/_sphinx_javascript_frameworks_compat.js"></script>
+        <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
         <script src="_static/doctools.js"></script>
+        <script src="_static/sphinx_highlight.js"></script>
     <script src="_static/js/theme.js"></script>
     <link rel="index" title="Index" href="genindex.html" />
     <link rel="search" title="Search" href="search.html" />
@@ -27,11 +28,15 @@
     <nav data-toggle="wy-nav-shift" class="wy-nav-side">
       <div class="wy-side-scroll">
         <div class="wy-side-nav-search" >
-            <a href="index.html" class="icon icon-home"> GEN DAQ API - Python Driver
+
+          
+          
+          <a href="index.html" class="icon icon-home">
+            GEN DAQ API - Python Driver
           </a>
 <div role="search">
   <form id="rtd-search-form" class="wy-form" action="search.html" method="get">
-    <input type="text" name="q" placeholder="Search docs" />
+    <input type="text" name="q" placeholder="Search docs" aria-label="Search docs" />
     <input type="hidden" name="check_keywords" value="yes" />
     <input type="hidden" name="area" value="default" />
   </form>
@@ -47,6 +52,7 @@
 <li class="toctree-l2"><a class="reference internal" href="managemainframe.html">Manage mainframe settings</a></li>
 <li class="toctree-l2"><a class="reference internal" href="recorder.html">Recorder</a></li>
 <li class="toctree-l2"><a class="reference internal" href="channel.html">Channel</a></li>
+<li class="toctree-l2"><a class="reference internal" href="fieldbus.html">FieldBus</a></li>
 </ul>
 </li>
 <li class="toctree-l1"><a class="reference internal" href="releasenotes.html">Release Notes</a></li>
@@ -66,8 +72,8 @@
         <div class="rst-content">
           <div role="navigation" aria-label="Page navigation">
   <ul class="wy-breadcrumbs">
-      <li><a href="index.html" class="icon icon-home"></a> &raquo;</li>
-      <li>API Functions</li>
+      <li><a href="index.html" class="icon icon-home" aria-label="Home"></a></li>
+      <li class="breadcrumb-item active">API Functions</li>
       <li class="wy-breadcrumbs-aside">
             <a href="_sources/ghspyapi.rst.txt" rel="nofollow"> View page source</a>
       </li>
@@ -78,21 +84,84 @@
            <div itemprop="articleBody">
              
   <section id="api-functions">
-<h1>API Functions<a class="headerlink" href="#api-functions" title="Permalink to this headline"></a></h1>
+<h1>API Functions<a class="headerlink" href="#api-functions" title="Permalink to this heading"></a></h1>
 <p>All available API functions:</p>
 <div class="toctree-wrapper compound">
 <ul>
-<li class="toctree-l1"><a class="reference internal" href="connections.html">Connections</a></li>
-<li class="toctree-l1"><a class="reference internal" href="acquisition.html">Acquisition control</a></li>
-<li class="toctree-l1"><a class="reference internal" href="mainframe.html">Mainframe</a></li>
-<li class="toctree-l1"><a class="reference internal" href="managerecording.html">Manage recordings</a></li>
-<li class="toctree-l1"><a class="reference internal" href="managemainframe.html">Manage mainframe settings</a></li>
-<li class="toctree-l1"><a class="reference internal" href="recorder.html">Recorder</a></li>
+<li class="toctree-l1"><a class="reference internal" href="connections.html">Connections</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="connections.html#ghsapi.ghsapi.GHS.ghs_connect"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_connect()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="connections.html#ghsapi.ghsapi.GHS.ghs_disconnect"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_disconnect()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="connections.html#ghsapi.ghsapi.GHS.ghs_get_client_api_version"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_client_api_version()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="connections.html#ghsapi.ghsapi.GHS.ghs_get_current_access"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_current_access()</span></code></a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="acquisition.html">Acquisition control</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="acquisition.html#ghsapi.ghsapi.GHS.ghs_start_preview"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_start_preview()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="acquisition.html#ghsapi.ghsapi.GHS.ghs_stop_preview"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_stop_preview()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="acquisition.html#ghsapi.ghsapi.GHS.ghs_start_recording"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_start_recording()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="acquisition.html#ghsapi.ghsapi.GHS.ghs_pause_recording"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_pause_recording()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="acquisition.html#ghsapi.ghsapi.GHS.ghs_resume_recording"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_resume_recording()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="acquisition.html#ghsapi.ghsapi.GHS.ghs_stop_recording"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_stop_recording()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="acquisition.html#ghsapi.ghsapi.GHS.ghs_trigger"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_trigger()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="acquisition.html#ghsapi.ghsapi.GHS.ghs_get_acquisition_state"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_acquisition_state()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="acquisition.html#ghsapi.ghsapi.GHS.ghs_get_acquisition_time"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_acquisition_time()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="acquisition.html#ghsapi.ghsapi.GHS.ghs_get_acquisition_start_time"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_acquisition_start_time()</span></code></a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="mainframe.html">Mainframe</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="mainframe.html#ghsapi.ghsapi.GHS.ghs_identify"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_identify()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="mainframe.html#ghsapi.ghsapi.GHS.ghs_get_disk_space"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_disk_space()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="mainframe.html#ghsapi.ghsapi.GHS.ghs_get_sync_status"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_sync_status()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="mainframe.html#ghsapi.ghsapi.GHS.ghs_get_slot_count"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_slot_count()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="mainframe.html#ghsapi.ghsapi.GHS.ghs_get_user_mode"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_user_mode()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="mainframe.html#ghsapi.ghsapi.GHS.ghs_set_user_mode"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_set_user_mode()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="mainframe.html#ghsapi.ghsapi.GHS.ghs_get_mainframe_info"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_mainframe_info()</span></code></a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="managerecording.html">Manage recordings</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="managerecording.html#ghsapi.ghsapi.GHS.ghs_get_storage_location"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_storage_location()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="managerecording.html#ghsapi.ghsapi.GHS.ghs_set_storage_location"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_set_storage_location()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="managerecording.html#ghsapi.ghsapi.GHS.ghs_get_recording_name"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_recording_name()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="managerecording.html#ghsapi.ghsapi.GHS.ghs_set_recording_name"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_set_recording_name()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="managerecording.html#ghsapi.ghsapi.GHS.ghs_delete_last_recording"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_delete_last_recording()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="managerecording.html#ghsapi.ghsapi.GHS.ghs_delete_all_recordings"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_delete_all_recordings()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="managerecording.html#ghsapi.ghsapi.GHS.ghs_get_high_low_rate_storage_enabled"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_high_low_rate_storage_enabled()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="managerecording.html#ghsapi.ghsapi.GHS.ghs_set_high_low_rate_storage_enabled"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_set_high_low_rate_storage_enabled()</span></code></a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="managemainframe.html">Manage mainframe settings</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="managemainframe.html#ghsapi.ghsapi.GHS.ghs_get_current_settings"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_current_settings()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="managemainframe.html#ghsapi.ghsapi.GHS.ghs_set_current_settings"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_set_current_settings()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="managemainframe.html#ghsapi.ghsapi.GHS.ghs_persist_current_settings"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_persist_current_settings()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="managemainframe.html#ghsapi.ghsapi.GHS.ghs_apply_persisted_settings"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_apply_persisted_settings()</span></code></a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="recorder.html">Recorder</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="recorder.html#ghsapi.ghsapi.GHS.ghs_get_recorder_info"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_recorder_info()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="recorder.html#ghsapi.ghsapi.GHS.ghs_get_recorder_enabled"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_recorder_enabled()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="recorder.html#ghsapi.ghsapi.GHS.ghs_set_recorder_enabled"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_set_recorder_enabled()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="recorder.html#ghsapi.ghsapi.GHS.ghs_get_channel_count"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_channel_count()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="recorder.html#ghsapi.ghsapi.GHS.ghs_get_sample_rate"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_sample_rate()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="recorder.html#ghsapi.ghsapi.GHS.ghs_set_sample_rate"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_set_sample_rate()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="recorder.html#ghsapi.ghsapi.GHS.ghs_get_digital_output"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_digital_output()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="recorder.html#ghsapi.ghsapi.GHS.ghs_set_digital_output"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_set_digital_output()</span></code></a></li>
+</ul>
+</li>
 <li class="toctree-l1"><a class="reference internal" href="channel.html">Channel</a><ul>
 <li class="toctree-l2"><a class="reference internal" href="channel.html#modules">Modules</a></li>
 <li class="toctree-l2"><a class="reference internal" href="channel.html#functions">Functions</a></li>
 </ul>
 </li>
+<li class="toctree-l1"><a class="reference internal" href="fieldbus.html">FieldBus</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="fieldbus.html#ghsapi.ghsapi.GHS.ghs_get_fieldbus_data_count"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_fieldbus_data_count()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="fieldbus.html#ghsapi.ghsapi.GHS.ghs_get_fieldbus_data_name_and_unit"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_fieldbus_data_name_and_unit()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="fieldbus.html#ghsapi.ghsapi.GHS.ghs_initiate_fieldbus_data_transfer"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_initiate_fieldbus_data_transfer()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="fieldbus.html#ghsapi.ghsapi.GHS.ghs_stop_fieldbus_data_transfer"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_stop_fieldbus_data_transfer()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="fieldbus.html#ghsapi.ghsapi.GHS.ghs_receive_fieldbus_data"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_receive_fieldbus_data()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="fieldbus.html#ghsapi.ghsapi.GHS.ghs_read_next_snapshot"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_read_next_snapshot()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="fieldbus.html#ghsapi.ghsapi.GHS.ghs_request_fieldbus_snapshot"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_request_fieldbus_snapshot()</span></code></a></li>
+</ul>
+</li>
 </ul>
 </div>
 </section>
diff --git a/docs/html/index.html b/docs/html/index.html
index 8b881a7..242dcc1 100644
--- a/docs/html/index.html
+++ b/docs/html/index.html
@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html class="writer-html5" lang="en" >
 <head>
-  <meta charset="utf-8" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
+  <meta charset="utf-8" /><meta name="generator" content="Docutils 0.18.1: http://docutils.sourceforge.net/" />
 
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <title>GEN DAQ API - Python Driver’s documentation &mdash; GEN DAQ API - Python Driver 1.1 documentation</title>
@@ -11,10 +11,11 @@
     <script src="_static/js/html5shiv.min.js"></script>
   <![endif]-->
   
-        <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
         <script src="_static/jquery.js"></script>
-        <script src="_static/underscore.js"></script>
+        <script src="_static/_sphinx_javascript_frameworks_compat.js"></script>
+        <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
         <script src="_static/doctools.js"></script>
+        <script src="_static/sphinx_highlight.js"></script>
     <script src="_static/js/theme.js"></script>
     <link rel="index" title="Index" href="genindex.html" />
     <link rel="search" title="Search" href="search.html" />
@@ -26,11 +27,15 @@
     <nav data-toggle="wy-nav-shift" class="wy-nav-side">
       <div class="wy-side-scroll">
         <div class="wy-side-nav-search" >
-            <a href="#" class="icon icon-home"> GEN DAQ API - Python Driver
+
+          
+          
+          <a href="#" class="icon icon-home">
+            GEN DAQ API - Python Driver
           </a>
 <div role="search">
   <form id="rtd-search-form" class="wy-form" action="search.html" method="get">
-    <input type="text" name="q" placeholder="Search docs" />
+    <input type="text" name="q" placeholder="Search docs" aria-label="Search docs" />
     <input type="hidden" name="check_keywords" value="yes" />
     <input type="hidden" name="area" value="default" />
   </form>
@@ -56,8 +61,8 @@
         <div class="rst-content">
           <div role="navigation" aria-label="Page navigation">
   <ul class="wy-breadcrumbs">
-      <li><a href="#" class="icon icon-home"></a> &raquo;</li>
-      <li>GEN DAQ API - Python Driver’s documentation</li>
+      <li><a href="#" class="icon icon-home" aria-label="Home"></a></li>
+      <li class="breadcrumb-item active">GEN DAQ API - Python Driver’s documentation</li>
       <li class="wy-breadcrumbs-aside">
             <a href="_sources/index.rst.txt" rel="nofollow"> View page source</a>
       </li>
@@ -68,13 +73,13 @@
            <div itemprop="articleBody">
              
   <section id="gen-daq-api-python-driver-s-documentation">
-<h1>GEN DAQ API - Python Driver’s documentation<a class="headerlink" href="#gen-daq-api-python-driver-s-documentation" title="Permalink to this headline"></a></h1>
+<h1>GEN DAQ API - Python Driver’s documentation<a class="headerlink" href="#gen-daq-api-python-driver-s-documentation" title="Permalink to this heading"></a></h1>
 <p>Welcome to the <strong>GEN DAQ API - Python Driver</strong> help file.</p>
 <p>The GEN DAQ API can be used to control the HBM GEN Series tethered mainframes without using Perception.
 Perception is a Microsoft® Windows® based application used for controlling all HBM GEN Series mainframes.
 These mainframes can even run unattended, in practice the GEN DAQ API will most often be used to control the mainframe.</p>
 <section id="contents">
-<h2>Contents<a class="headerlink" href="#contents" title="Permalink to this headline"></a></h2>
+<h2>Contents<a class="headerlink" href="#contents" title="Permalink to this heading"></a></h2>
 <div class="toctree-wrapper compound">
 <ul>
 <li class="toctree-l1"><a class="reference internal" href="introduction.html">Introduction</a></li>
@@ -86,6 +91,7 @@ <h2>Contents<a class="headerlink" href="#contents" title="Permalink to this head
 <li class="toctree-l2"><a class="reference internal" href="managemainframe.html">Manage mainframe settings</a></li>
 <li class="toctree-l2"><a class="reference internal" href="recorder.html">Recorder</a></li>
 <li class="toctree-l2"><a class="reference internal" href="channel.html">Channel</a></li>
+<li class="toctree-l2"><a class="reference internal" href="fieldbus.html">FieldBus</a></li>
 </ul>
 </li>
 <li class="toctree-l1"><a class="reference internal" href="releasenotes.html">Release Notes</a><ul>
diff --git a/docs/html/introduction.html b/docs/html/introduction.html
index fb212ed..776ddb9 100644
--- a/docs/html/introduction.html
+++ b/docs/html/introduction.html
@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html class="writer-html5" lang="en" >
 <head>
-  <meta charset="utf-8" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
+  <meta charset="utf-8" /><meta name="generator" content="Docutils 0.18.1: http://docutils.sourceforge.net/" />
 
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <title>Introduction &mdash; GEN DAQ API - Python Driver 1.1 documentation</title>
@@ -11,10 +11,11 @@
     <script src="_static/js/html5shiv.min.js"></script>
   <![endif]-->
   
-        <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
         <script src="_static/jquery.js"></script>
-        <script src="_static/underscore.js"></script>
+        <script src="_static/_sphinx_javascript_frameworks_compat.js"></script>
+        <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
         <script src="_static/doctools.js"></script>
+        <script src="_static/sphinx_highlight.js"></script>
     <script src="_static/js/theme.js"></script>
     <link rel="index" title="Index" href="genindex.html" />
     <link rel="search" title="Search" href="search.html" />
@@ -27,11 +28,15 @@
     <nav data-toggle="wy-nav-shift" class="wy-nav-side">
       <div class="wy-side-scroll">
         <div class="wy-side-nav-search" >
-            <a href="index.html" class="icon icon-home"> GEN DAQ API - Python Driver
+
+          
+          
+          <a href="index.html" class="icon icon-home">
+            GEN DAQ API - Python Driver
           </a>
 <div role="search">
   <form id="rtd-search-form" class="wy-form" action="search.html" method="get">
-    <input type="text" name="q" placeholder="Search docs" />
+    <input type="text" name="q" placeholder="Search docs" aria-label="Search docs" />
     <input type="hidden" name="check_keywords" value="yes" />
     <input type="hidden" name="area" value="default" />
   </form>
@@ -57,8 +62,8 @@
         <div class="rst-content">
           <div role="navigation" aria-label="Page navigation">
   <ul class="wy-breadcrumbs">
-      <li><a href="index.html" class="icon icon-home"></a> &raquo;</li>
-      <li>Introduction</li>
+      <li><a href="index.html" class="icon icon-home" aria-label="Home"></a></li>
+      <li class="breadcrumb-item active">Introduction</li>
       <li class="wy-breadcrumbs-aside">
             <a href="_sources/introduction.rst.txt" rel="nofollow"> View page source</a>
       </li>
@@ -69,7 +74,7 @@
            <div itemprop="articleBody">
              
   <section id="introduction">
-<h1>Introduction<a class="headerlink" href="#introduction" title="Permalink to this headline"></a></h1>
+<h1>Introduction<a class="headerlink" href="#introduction" title="Permalink to this heading"></a></h1>
 <p>Welcome to the <strong>GEN DAQ API - Python Driver</strong> help file.
 The GEN DAQ API can be used to control the HBM GEN Series tethered mainframes without using Perception.
 Perception is a Microsoft® Windows® based application used for controlling all HBM GEN Series mainframes.
diff --git a/docs/html/mainframe.html b/docs/html/mainframe.html
index 52fa905..c2ed52d 100644
--- a/docs/html/mainframe.html
+++ b/docs/html/mainframe.html
@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html class="writer-html5" lang="en" >
 <head>
-  <meta charset="utf-8" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
+  <meta charset="utf-8" /><meta name="generator" content="Docutils 0.18.1: http://docutils.sourceforge.net/" />
 
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <title>Mainframe &mdash; GEN DAQ API - Python Driver 1.1 documentation</title>
@@ -11,10 +11,11 @@
     <script src="_static/js/html5shiv.min.js"></script>
   <![endif]-->
   
-        <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
         <script src="_static/jquery.js"></script>
-        <script src="_static/underscore.js"></script>
+        <script src="_static/_sphinx_javascript_frameworks_compat.js"></script>
+        <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
         <script src="_static/doctools.js"></script>
+        <script src="_static/sphinx_highlight.js"></script>
     <script src="_static/js/theme.js"></script>
     <link rel="index" title="Index" href="genindex.html" />
     <link rel="search" title="Search" href="search.html" />
@@ -27,11 +28,15 @@
     <nav data-toggle="wy-nav-shift" class="wy-nav-side">
       <div class="wy-side-scroll">
         <div class="wy-side-nav-search" >
-            <a href="index.html" class="icon icon-home"> GEN DAQ API - Python Driver
+
+          
+          
+          <a href="index.html" class="icon icon-home">
+            GEN DAQ API - Python Driver
           </a>
 <div role="search">
   <form id="rtd-search-form" class="wy-form" action="search.html" method="get">
-    <input type="text" name="q" placeholder="Search docs" />
+    <input type="text" name="q" placeholder="Search docs" aria-label="Search docs" />
     <input type="hidden" name="check_keywords" value="yes" />
     <input type="hidden" name="area" value="default" />
   </form>
@@ -44,7 +49,16 @@
 <li class="toctree-l2 current"><a class="reference internal" href="releasenotes.html#version-1-0">Version 1.0</a><ul class="current">
 <li class="toctree-l3"><a class="reference internal" href="connections.html">Connections</a></li>
 <li class="toctree-l3"><a class="reference internal" href="acquisition.html">Acquisition control</a></li>
-<li class="toctree-l3 current"><a class="current reference internal" href="#">Mainframe</a></li>
+<li class="toctree-l3 current"><a class="current reference internal" href="#">Mainframe</a><ul>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_identify"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_identify()</span></code></a></li>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_get_disk_space"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_disk_space()</span></code></a></li>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_get_sync_status"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_sync_status()</span></code></a></li>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_get_slot_count"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_slot_count()</span></code></a></li>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_get_user_mode"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_user_mode()</span></code></a></li>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_set_user_mode"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_set_user_mode()</span></code></a></li>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_get_mainframe_info"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_mainframe_info()</span></code></a></li>
+</ul>
+</li>
 <li class="toctree-l3"><a class="reference internal" href="managerecording.html">Manage recordings</a></li>
 <li class="toctree-l3"><a class="reference internal" href="managemainframe.html">Manage mainframe settings</a></li>
 <li class="toctree-l3"><a class="reference internal" href="recorder.html">Recorder</a></li>
@@ -69,9 +83,9 @@
         <div class="rst-content">
           <div role="navigation" aria-label="Page navigation">
   <ul class="wy-breadcrumbs">
-      <li><a href="index.html" class="icon icon-home"></a> &raquo;</li>
-          <li><a href="ghspyapi.html">API Functions</a> &raquo;</li>
-      <li>Mainframe</li>
+      <li><a href="index.html" class="icon icon-home" aria-label="Home"></a></li>
+          <li class="breadcrumb-item"><a href="ghspyapi.html">API Functions</a></li>
+      <li class="breadcrumb-item active">Mainframe</li>
       <li class="wy-breadcrumbs-aside">
             <a href="_sources/mainframe.rst.txt" rel="nofollow"> View page source</a>
       </li>
@@ -82,7 +96,7 @@
            <div itemprop="articleBody">
              
   <section id="mainframe">
-<h1>Mainframe<a class="headerlink" href="#mainframe" title="Permalink to this headline"></a></h1>
+<h1>Mainframe<a class="headerlink" href="#mainframe" title="Permalink to this heading"></a></h1>
 <p>Mainframe related API functions.</p>
 <dl class="py method">
 <dt class="sig sig-object py" id="ghsapi.ghsapi.GHS.ghs_identify">
@@ -90,10 +104,10 @@ <h1>Mainframe<a class="headerlink" href="#mainframe" title="Permalink to this he
 <dd><p>Enable or disable the identification sound of the connected
 mainframe.</p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><p><strong>identity_flag</strong> – Enable or disable flag.</p>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - Identify API status.</p></li>
 </ul>
@@ -107,7 +121,7 @@ <h1>Mainframe<a class="headerlink" href="#mainframe" title="Permalink to this he
 <span class="sig-prename descclassname"><span class="pre">GHS.</span></span><span class="sig-name descname"><span class="pre">ghs_get_disk_space</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span> <span class="sig-return"><span class="sig-return-icon">&#x2192;</span> <span class="sig-return-typehint"><span class="pre">tuple</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">,</span></span><span class="w"> </span><span class="pre">float</span><span class="w"> </span><span class="p"><span class="pre">|</span></span><span class="w"> </span><span class="pre">None</span><span class="p"><span class="pre">,</span></span><span class="w"> </span><span class="pre">float</span><span class="w"> </span><span class="p"><span class="pre">|</span></span><span class="w"> </span><span class="pre">None</span><span class="p"><span class="pre">]</span></span></span></span><a class="reference internal" href="_modules/ghsapi/ghsapi.html#GHS.ghs_get_disk_space"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#ghsapi.ghsapi.GHS.ghs_get_disk_space" title="Permalink to this definition"></a></dt>
 <dd><p>Get total and available mainframe internal disk space.</p>
 <dl class="field-list simple">
-<dt class="field-odd">Returns</dt>
+<dt class="field-odd">Returns<span class="colon">:</span></dt>
 <dd class="field-odd"><p><ul class="simple">
 <li><p>GHSReturnValue - API return status</p></li>
 <li><p>total - Total mainframe internal disk space in GB</p></li>
@@ -123,7 +137,7 @@ <h1>Mainframe<a class="headerlink" href="#mainframe" title="Permalink to this he
 <span class="sig-prename descclassname"><span class="pre">GHS.</span></span><span class="sig-name descname"><span class="pre">ghs_get_sync_status</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span> <span class="sig-return"><span class="sig-return-icon">&#x2192;</span> <span class="sig-return-typehint"><span class="pre">tuple</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">,</span></span><span class="w"> </span><span class="pre">str</span><span class="w"> </span><span class="p"><span class="pre">|</span></span><span class="w"> </span><span class="pre">None</span><span class="p"><span class="pre">]</span></span></span></span><a class="reference internal" href="_modules/ghsapi/ghsapi.html#GHS.ghs_get_sync_status"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#ghsapi.ghsapi.GHS.ghs_get_sync_status" title="Permalink to this definition"></a></dt>
 <dd><p>Determine the mainframe sync status.</p>
 <dl class="field-list simple">
-<dt class="field-odd">Returns</dt>
+<dt class="field-odd">Returns<span class="colon">:</span></dt>
 <dd class="field-odd"><p><ul class="simple">
 <li><p>GHSReturnValue - API return status</p></li>
 <li><p>GHSSyncStatus - Sync status</p></li>
@@ -138,7 +152,7 @@ <h1>Mainframe<a class="headerlink" href="#mainframe" title="Permalink to this he
 <span class="sig-prename descclassname"><span class="pre">GHS.</span></span><span class="sig-name descname"><span class="pre">ghs_get_slot_count</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span> <span class="sig-return"><span class="sig-return-icon">&#x2192;</span> <span class="sig-return-typehint"><span class="pre">tuple</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">,</span></span><span class="w"> </span><span class="pre">int</span><span class="w"> </span><span class="p"><span class="pre">|</span></span><span class="w"> </span><span class="pre">None</span><span class="p"><span class="pre">]</span></span></span></span><a class="reference internal" href="_modules/ghsapi/ghsapi.html#GHS.ghs_get_slot_count"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#ghsapi.ghsapi.GHS.ghs_get_slot_count" title="Permalink to this definition"></a></dt>
 <dd><p>Retrieve the number of slots in the mainframe.</p>
 <dl class="field-list simple">
-<dt class="field-odd">Returns</dt>
+<dt class="field-odd">Returns<span class="colon">:</span></dt>
 <dd class="field-odd"><p><ul class="simple">
 <li><p>GHSReturnValue - API return status</p></li>
 <li><p>slot_count - The number of slots in the mainframe</p></li>
@@ -153,7 +167,7 @@ <h1>Mainframe<a class="headerlink" href="#mainframe" title="Permalink to this he
 <span class="sig-prename descclassname"><span class="pre">GHS.</span></span><span class="sig-name descname"><span class="pre">ghs_get_user_mode</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span> <span class="sig-return"><span class="sig-return-icon">&#x2192;</span> <span class="sig-return-typehint"><span class="pre">tuple</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">,</span></span><span class="w"> </span><span class="pre">str</span><span class="w"> </span><span class="p"><span class="pre">|</span></span><span class="w"> </span><span class="pre">None</span><span class="p"><span class="pre">]</span></span></span></span><a class="reference internal" href="_modules/ghsapi/ghsapi.html#GHS.ghs_get_user_mode"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#ghsapi.ghsapi.GHS.ghs_get_user_mode" title="Permalink to this definition"></a></dt>
 <dd><p>Retrieve the user mode.</p>
 <dl class="field-list simple">
-<dt class="field-odd">Returns</dt>
+<dt class="field-odd">Returns<span class="colon">:</span></dt>
 <dd class="field-odd"><p><ul class="simple">
 <li><p>GHSReturnValue - API return status</p></li>
 <li><p>GHSUserMode - The user mode</p></li>
@@ -169,10 +183,10 @@ <h1>Mainframe<a class="headerlink" href="#mainframe" title="Permalink to this he
 <dd><p>Set the user mode.</p>
 <p><em>The system needs to be idle before calling this function.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><p><strong>user_mode</strong> – The desired user mode.</p>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return status</p></li>
 </ul>
@@ -189,7 +203,7 @@ <h1>Mainframe<a class="headerlink" href="#mainframe" title="Permalink to this he
 <p><em>The mainframeType, mainframeName, serialNumber and
 firmwareVersion parameters are UTF-8 encoded.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Returns</dt>
+<dt class="field-odd">Returns<span class="colon">:</span></dt>
 <dd class="field-odd"><p><ul class="simple">
 <li><p>GHSReturnValue - API return status</p></li>
 <li><p>mainframe_type - The type of the mainframe</p></li>
diff --git a/docs/html/managemainframe.html b/docs/html/managemainframe.html
index 8b2c4aa..4e2098d 100644
--- a/docs/html/managemainframe.html
+++ b/docs/html/managemainframe.html
@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html class="writer-html5" lang="en" >
 <head>
-  <meta charset="utf-8" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
+  <meta charset="utf-8" /><meta name="generator" content="Docutils 0.18.1: http://docutils.sourceforge.net/" />
 
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <title>Manage mainframe settings &mdash; GEN DAQ API - Python Driver 1.1 documentation</title>
@@ -11,10 +11,11 @@
     <script src="_static/js/html5shiv.min.js"></script>
   <![endif]-->
   
-        <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
         <script src="_static/jquery.js"></script>
-        <script src="_static/underscore.js"></script>
+        <script src="_static/_sphinx_javascript_frameworks_compat.js"></script>
+        <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
         <script src="_static/doctools.js"></script>
+        <script src="_static/sphinx_highlight.js"></script>
     <script src="_static/js/theme.js"></script>
     <link rel="index" title="Index" href="genindex.html" />
     <link rel="search" title="Search" href="search.html" />
@@ -27,11 +28,15 @@
     <nav data-toggle="wy-nav-shift" class="wy-nav-side">
       <div class="wy-side-scroll">
         <div class="wy-side-nav-search" >
-            <a href="index.html" class="icon icon-home"> GEN DAQ API - Python Driver
+
+          
+          
+          <a href="index.html" class="icon icon-home">
+            GEN DAQ API - Python Driver
           </a>
 <div role="search">
   <form id="rtd-search-form" class="wy-form" action="search.html" method="get">
-    <input type="text" name="q" placeholder="Search docs" />
+    <input type="text" name="q" placeholder="Search docs" aria-label="Search docs" />
     <input type="hidden" name="check_keywords" value="yes" />
     <input type="hidden" name="area" value="default" />
   </form>
@@ -46,7 +51,13 @@
 <li class="toctree-l3"><a class="reference internal" href="acquisition.html">Acquisition control</a></li>
 <li class="toctree-l3"><a class="reference internal" href="mainframe.html">Mainframe</a></li>
 <li class="toctree-l3"><a class="reference internal" href="managerecording.html">Manage recordings</a></li>
-<li class="toctree-l3 current"><a class="current reference internal" href="#">Manage mainframe settings</a></li>
+<li class="toctree-l3 current"><a class="current reference internal" href="#">Manage mainframe settings</a><ul>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_get_current_settings"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_current_settings()</span></code></a></li>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_set_current_settings"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_set_current_settings()</span></code></a></li>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_persist_current_settings"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_persist_current_settings()</span></code></a></li>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_apply_persisted_settings"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_apply_persisted_settings()</span></code></a></li>
+</ul>
+</li>
 <li class="toctree-l3"><a class="reference internal" href="recorder.html">Recorder</a></li>
 </ul>
 </li>
@@ -69,9 +80,9 @@
         <div class="rst-content">
           <div role="navigation" aria-label="Page navigation">
   <ul class="wy-breadcrumbs">
-      <li><a href="index.html" class="icon icon-home"></a> &raquo;</li>
-          <li><a href="ghspyapi.html">API Functions</a> &raquo;</li>
-      <li>Manage mainframe settings</li>
+      <li><a href="index.html" class="icon icon-home" aria-label="Home"></a></li>
+          <li class="breadcrumb-item"><a href="ghspyapi.html">API Functions</a></li>
+      <li class="breadcrumb-item active">Manage mainframe settings</li>
       <li class="wy-breadcrumbs-aside">
             <a href="_sources/managemainframe.rst.txt" rel="nofollow"> View page source</a>
       </li>
@@ -82,7 +93,7 @@
            <div itemprop="articleBody">
              
   <section id="manage-mainframe-settings">
-<h1>Manage mainframe settings<a class="headerlink" href="#manage-mainframe-settings" title="Permalink to this headline"></a></h1>
+<h1>Manage mainframe settings<a class="headerlink" href="#manage-mainframe-settings" title="Permalink to this heading"></a></h1>
 <p>Settings management related API functions.</p>
 <dl class="py method">
 <dt class="sig sig-object py" id="ghsapi.ghsapi.GHS.ghs_get_current_settings">
@@ -92,7 +103,7 @@ <h1>Manage mainframe settings<a class="headerlink" href="#manage-mainframe-setti
 ensure reading the correct amount of memory.
 Memory for this blob is allocated by the API.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Returns</dt>
+<dt class="field-odd">Returns<span class="colon">:</span></dt>
 <dd class="field-odd"><p><ul class="simple">
 <li><p>GHSReturnValue - API return status</p></li>
 <li><p>blob - Pointer to the settings blob</p></li>
@@ -110,13 +121,13 @@ <h1>Manage mainframe settings<a class="headerlink" href="#manage-mainframe-setti
 <p><em>The persisted mainframe settings are applied upon a mainframe
 boot.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>blob</strong> – Settings blob.</p></li>
 <li><p><strong>blob_size</strong> – Size of the settings blob.</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return status</p></li>
 </ul>
@@ -132,7 +143,7 @@ <h1>Manage mainframe settings<a class="headerlink" href="#manage-mainframe-setti
 <p><em>The persisted mainframe settings are applied upon a mainframe
 boot.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Returns</dt>
+<dt class="field-odd">Returns<span class="colon">:</span></dt>
 <dd class="field-odd"><p><ul class="simple">
 <li><p>GHSReturnValue - API return status</p></li>
 </ul>
@@ -151,7 +162,7 @@ <h1>Manage mainframe settings<a class="headerlink" href="#manage-mainframe-setti
 This function overwrites any previously set settings and / or
 persisted settings.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Returns</dt>
+<dt class="field-odd">Returns<span class="colon">:</span></dt>
 <dd class="field-odd"><p>API status.</p>
 </dd>
 </dl>
diff --git a/docs/html/managerecording.html b/docs/html/managerecording.html
index 8ce0148..4c58302 100644
--- a/docs/html/managerecording.html
+++ b/docs/html/managerecording.html
@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html class="writer-html5" lang="en" >
 <head>
-  <meta charset="utf-8" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
+  <meta charset="utf-8" /><meta name="generator" content="Docutils 0.18.1: http://docutils.sourceforge.net/" />
 
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <title>Manage recordings &mdash; GEN DAQ API - Python Driver 1.1 documentation</title>
@@ -11,10 +11,11 @@
     <script src="_static/js/html5shiv.min.js"></script>
   <![endif]-->
   
-        <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
         <script src="_static/jquery.js"></script>
-        <script src="_static/underscore.js"></script>
+        <script src="_static/_sphinx_javascript_frameworks_compat.js"></script>
+        <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
         <script src="_static/doctools.js"></script>
+        <script src="_static/sphinx_highlight.js"></script>
     <script src="_static/js/theme.js"></script>
     <link rel="index" title="Index" href="genindex.html" />
     <link rel="search" title="Search" href="search.html" />
@@ -27,11 +28,15 @@
     <nav data-toggle="wy-nav-shift" class="wy-nav-side">
       <div class="wy-side-scroll">
         <div class="wy-side-nav-search" >
-            <a href="index.html" class="icon icon-home"> GEN DAQ API - Python Driver
+
+          
+          
+          <a href="index.html" class="icon icon-home">
+            GEN DAQ API - Python Driver
           </a>
 <div role="search">
   <form id="rtd-search-form" class="wy-form" action="search.html" method="get">
-    <input type="text" name="q" placeholder="Search docs" />
+    <input type="text" name="q" placeholder="Search docs" aria-label="Search docs" />
     <input type="hidden" name="check_keywords" value="yes" />
     <input type="hidden" name="area" value="default" />
   </form>
@@ -45,7 +50,17 @@
 <li class="toctree-l3"><a class="reference internal" href="connections.html">Connections</a></li>
 <li class="toctree-l3"><a class="reference internal" href="acquisition.html">Acquisition control</a></li>
 <li class="toctree-l3"><a class="reference internal" href="mainframe.html">Mainframe</a></li>
-<li class="toctree-l3 current"><a class="current reference internal" href="#">Manage recordings</a></li>
+<li class="toctree-l3 current"><a class="current reference internal" href="#">Manage recordings</a><ul>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_get_storage_location"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_storage_location()</span></code></a></li>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_set_storage_location"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_set_storage_location()</span></code></a></li>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_get_recording_name"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_recording_name()</span></code></a></li>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_set_recording_name"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_set_recording_name()</span></code></a></li>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_delete_last_recording"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_delete_last_recording()</span></code></a></li>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_delete_all_recordings"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_delete_all_recordings()</span></code></a></li>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_get_high_low_rate_storage_enabled"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_high_low_rate_storage_enabled()</span></code></a></li>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_set_high_low_rate_storage_enabled"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_set_high_low_rate_storage_enabled()</span></code></a></li>
+</ul>
+</li>
 <li class="toctree-l3"><a class="reference internal" href="managemainframe.html">Manage mainframe settings</a></li>
 <li class="toctree-l3"><a class="reference internal" href="recorder.html">Recorder</a></li>
 </ul>
@@ -69,9 +84,9 @@
         <div class="rst-content">
           <div role="navigation" aria-label="Page navigation">
   <ul class="wy-breadcrumbs">
-      <li><a href="index.html" class="icon icon-home"></a> &raquo;</li>
-          <li><a href="ghspyapi.html">API Functions</a> &raquo;</li>
-      <li>Manage recordings</li>
+      <li><a href="index.html" class="icon icon-home" aria-label="Home"></a></li>
+          <li class="breadcrumb-item"><a href="ghspyapi.html">API Functions</a></li>
+      <li class="breadcrumb-item active">Manage recordings</li>
       <li class="wy-breadcrumbs-aside">
             <a href="_sources/managerecording.rst.txt" rel="nofollow"> View page source</a>
       </li>
@@ -82,14 +97,14 @@
            <div itemprop="articleBody">
              
   <section id="manage-recordings">
-<h1>Manage recordings<a class="headerlink" href="#manage-recordings" title="Permalink to this headline"></a></h1>
+<h1>Manage recordings<a class="headerlink" href="#manage-recordings" title="Permalink to this heading"></a></h1>
 <p>Recording management related API functions.</p>
 <dl class="py method">
 <dt class="sig sig-object py" id="ghsapi.ghsapi.GHS.ghs_get_storage_location">
 <span class="sig-prename descclassname"><span class="pre">GHS.</span></span><span class="sig-name descname"><span class="pre">ghs_get_storage_location</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span> <span class="sig-return"><span class="sig-return-icon">&#x2192;</span> <span class="sig-return-typehint"><span class="pre">tuple</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">,</span></span><span class="w"> </span><span class="pre">str</span><span class="w"> </span><span class="p"><span class="pre">|</span></span><span class="w"> </span><span class="pre">None</span><span class="p"><span class="pre">]</span></span></span></span><a class="reference internal" href="_modules/ghsapi/ghsapi.html#GHS.ghs_get_storage_location"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#ghsapi.ghsapi.GHS.ghs_get_storage_location" title="Permalink to this definition"></a></dt>
 <dd><p>Retrieve the storage location.</p>
 <dl class="field-list simple">
-<dt class="field-odd">Returns</dt>
+<dt class="field-odd">Returns<span class="colon">:</span></dt>
 <dd class="field-odd"><p><ul class="simple">
 <li><p>GHSReturnValue - API return status</p></li>
 <li><p>GHSStorageLocation - The storage location</p></li>
@@ -105,10 +120,10 @@ <h1>Manage recordings<a class="headerlink" href="#manage-recordings" title="Perm
 <dd><p>Set the storage location.</p>
 <p><em>The system needs to be idle before calling this function.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><p><strong>storage_location</strong> – The desired storage location.</p>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return status</p></li>
 </ul>
@@ -124,7 +139,7 @@ <h1>Manage recordings<a class="headerlink" href="#manage-recordings" title="Perm
 last recording file.</p>
 <p><em>The recording base name parameter is UTF-8 encoded.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Returns</dt>
+<dt class="field-odd">Returns<span class="colon">:</span></dt>
 <dd class="field-odd"><p><ul class="simple">
 <li><p>GHSReturnValue - API return status</p></li>
 <li><p>recording_base_name - The base name of the recording file</p></li>
@@ -143,13 +158,13 @@ <h1>Manage recordings<a class="headerlink" href="#manage-recordings" title="Perm
 <p><em>The system needs to be idle before calling this function.
 The recording base name parameter must be UTF-8 encoded.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>recording_name</strong> – The desired base name of the recording file</p></li>
 <li><p><strong>recording_index</strong> – The desired index of the recording file</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return status</p></li>
 </ul>
@@ -165,7 +180,7 @@ <h1>Manage recordings<a class="headerlink" href="#manage-recordings" title="Perm
 storage.</p>
 <p><em>Recordings are deleted asynchronously.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Returns</dt>
+<dt class="field-odd">Returns<span class="colon">:</span></dt>
 <dd class="field-odd"><p><ul class="simple">
 <li><p>GHSReturnValue - API return status</p></li>
 </ul>
@@ -180,7 +195,7 @@ <h1>Manage recordings<a class="headerlink" href="#manage-recordings" title="Perm
 <dd><p>Deletes all recordings from local mainframe storage.</p>
 <p><em>Recordings are deleted asynchronously.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Returns</dt>
+<dt class="field-odd">Returns<span class="colon">:</span></dt>
 <dd class="field-odd"><p><ul class="simple">
 <li><p>GHSReturnValue - API return status</p></li>
 </ul>
@@ -195,13 +210,13 @@ <h1>Manage recordings<a class="headerlink" href="#manage-recordings" title="Perm
 <dd><p>Retrieve storage enabled status of high and low rate data
 for the specified recording data source.</p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>source</strong> – The recording data source</p></li>
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return status</p></li>
 <li><p>GHSEnableDisable - Flag to indicate if high rate data is stored</p></li>
@@ -218,7 +233,7 @@ <h1>Manage recordings<a class="headerlink" href="#manage-recordings" title="Perm
 <dd><p>Enable/disable storage of high and low rate data for the
 specified recording data source.</p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>source</strong> – The recording data source</p></li>
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
@@ -226,7 +241,7 @@ <h1>Manage recordings<a class="headerlink" href="#manage-recordings" title="Perm
 <li><p><strong>low_rate_enabled</strong> – Enable/disable storage of low rate data.</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return status</p></li>
 </ul>
diff --git a/docs/html/objects.inv b/docs/html/objects.inv
index 5250deb4b6f5668726bb76e17d556a21a12e789c..e27ced2358cdbd7fef136be95b037808a1d29033 100644
GIT binary patch
delta 1024
zcmV+b1poV_2>b|;iho(na-292zVj5S+FYHjTyyg}o1a5c-p$@svgiR-ghbTBHhbFF
z$m``vw#Cnk7;rp*d>UxFzv@4Ae=tRfqE@eq{^!HTui=u5y4EeP!J$GAIY;nbnF3ke
zzOBHQHfL{GC5$Mb63QH$sNi+!EB)Imc9j*2n6k>bXuRc4n12Geu@4h8Sqfu76Q;Js
zC0PH0v*gnf$g}2_w4|S!_A+G+K4+eT1`k|l%^gVV@+VSre0U+C7U)liy8spLjIjXE
zh5X(qR6(Dk7tV99DwrTfDjN`eGO*o_Rkc<J1&&uXhwY8oVI7-%AI@OFrO=$tm`#Lc
z8#C>SzN^5kL4Pr#f-NU6#z1c!H8lq#?lk0k;e1<fcS$QSRJmI5`!MvZ*>i4W<6H+P
zB_O6iN-=)}Uakt|shw=&>t=fw(0KXAu@(}}99rQDJW6uK&r-d%uj$b0{H~#yC%jnb
z?(zA0tkC0Jn4C98?ZMQZ#!BeU4(#CIdjm$c`@$|&QGar6A863f=J?f7TDdv`xH8lo
zA(u21mpAO?jvkw0KEqb^%h;cbF|KLeBhbvB^(d5``6%3wa18qgx>|1b2vtEvNmMn|
z)-N2URTZNFVY-&LhXW0;oem8huC1I8jV&2(jqE5$gWDtYAWNgdehwo7_eB^ejO%kw
zzePCKGk;byfOe|uF`uF~8{wX$IG5u&RZ!iQ*W2m@Hn<ey#RXM4ZCZ6`H(FBzs8F-%
z4)K&EJb>G@K59WBJ@G=Yg5M6WaY@O91CetBkA!AKjiueTASpIb_h(7lh(uczqZPi>
zFKns=smFw`7MSSO0u#`9OiSZ2G1bL1R2LJ`RDXOK8i+4R12G{D#8mVRlM*jXK)f&|
z@xqj(2@{hhOv!if1^5o8<vW;|?_g5CgZueT|3$BMaIfHD^MdO@_U}n=>y*r?!`mGi
zVeF1<DEaf|k&vO!-{w}btGO<_j`XB8-dUXutrOeDo0r}6H`%1c7PO<@W7pkv7Pt6<
z#eb>w*+1d(_nZE(WYLGNiP_orFLrYhWMg$>gGt5N`*8P1gINJanH(NFRW0r)cv2pv
zz4E7U8Ol<(RFN2Tlns&Ieq!$%GdOXA9h4))4}X4P@2>yqEUwsXOZ7DDog)V8e*X6Z
z8Cei*G(BG+Bq~nc$n%oM^3l_iBs(79*m-7ps@do9HalZRQ=2(yBFi9Tk-;#Fva@|K
zN1CpR5$W^~NJg`0p(u5GH9i;&DO3$Zd7`J!m<{QkSdVKuc6PG5+26w*scH}i#(Kc1
u`bj>TbQ1O@h{&!I?%SD3CmOZ8n+!oXSx#f<Wxd|l{`oECEc+il+VN4Mp8-Dr

delta 936
zcmV;Z16Ta~2&4#*iho#3a-1*_-E#_6CEIZ-Tkl+UK3>G-#M!H4(E}<A39E%|vdT4b
zy__V?Zw3aO89-hEP4}Btf8UU#C~|d{G?y=5@2Xoa@?4iZ2Zsth#2mqUWfEk0d7gn!
zZOlHhOc;?sCY0Gak-=H&GyU#8+eFDErp#h43U9d+CIN2j^M3$MrotG|gsE+E3f3=h
zmVBB5Icjc6OZuT{BU9GkG4mKSc;G^7?m$`>zY?0=%M$^$K)**^1*mZ4858ha$j3sV
zs`NQ};XL;$g8^bsWdWiO2DaL<EZ1tQ!12t+u)Hv9tX+|>!)Xn;6q-|y*+6KvFvF^7
zstVj36eBWN(tmk<4D{AfQFAcjUPHVV&X@Uem$U*ynadS_s)n95Yx+hO&ed>I0%8cH
z5c9Xfi&dgLm6I)eUM#Ny8ZQqVb0Oitp&72gizHY4DAaT7daJajwym<yg^Bsr!D9hN
zmg`_sm84wTXKG}c%>OIZnWMP^SB9crbs`O&=?!+eqkp@gk7vZJe02GrJmZ|=*a40F
znU6xz8IPI;0mo{-L!HaT9-&GoDS@(v+WLu6JS$_=fTk{ayWP@&Sm{t(;o8b^Q!a^k
zX=J_P3tWCe4>C2X+JA*n9@m|)q6n^uIbD;gtw*e(1+7)*W4=Zm7Q($sAx_70Dxthh
zuaDUQEPrt7j3*~l#k9%Pwp?bN3;Ow2$ngxW*Z!pmx>y}xkp=J#1M*M|#6vLv=fkj^
z4+HZe48w~s5U0Vn;WYS`oCX7O8VtonFer<_04xGSvIq>x05C8Ez>v!u-(Y!T*yW9Z
zmp2Ao-nf2wH=loU2Tux~7caOPWc{A>Hec@wVSlXlq)pLr^PZ5QkI!Q(*=DTEE_!;>
z8t<%*+En-L`kRtnHV@IDBqp?bwZbmy`>0=%6BheYWk0Li50_1GN4>8Y1G9sV8|-o~
zh!QZ$#PCuZXmL*`B9l(q=wDa2Rjl)p!rX`MWUc$R*X(m)TI4-!tK38U^67?MU3{-C
zHh=84q$C-3<<t|nzrX(=BMahgrdisAL=le*d6=iZyz_J~iFRGow;8q;`_?^12lQlU
zGiEMiSqWLspdAR&!B8F}4d-=-wEt!u(Lk6;N?vZd7p);3RYRMe-rFN)ZMX;4-LC9A
zJJ_G>NBcyo8U%u|9&o6>mv<($gxypkvLVZadpIzuMV)s25FrRB)8QE!S)+H?yuYQG
KMgIWpI~!Fyk;RDs

diff --git a/docs/html/recorder.html b/docs/html/recorder.html
index 11c977c..399d2ee 100644
--- a/docs/html/recorder.html
+++ b/docs/html/recorder.html
@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html class="writer-html5" lang="en" >
 <head>
-  <meta charset="utf-8" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
+  <meta charset="utf-8" /><meta name="generator" content="Docutils 0.18.1: http://docutils.sourceforge.net/" />
 
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <title>Recorder &mdash; GEN DAQ API - Python Driver 1.1 documentation</title>
@@ -11,10 +11,11 @@
     <script src="_static/js/html5shiv.min.js"></script>
   <![endif]-->
   
-        <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
         <script src="_static/jquery.js"></script>
-        <script src="_static/underscore.js"></script>
+        <script src="_static/_sphinx_javascript_frameworks_compat.js"></script>
+        <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
         <script src="_static/doctools.js"></script>
+        <script src="_static/sphinx_highlight.js"></script>
     <script src="_static/js/theme.js"></script>
     <link rel="index" title="Index" href="genindex.html" />
     <link rel="search" title="Search" href="search.html" />
@@ -27,11 +28,15 @@
     <nav data-toggle="wy-nav-shift" class="wy-nav-side">
       <div class="wy-side-scroll">
         <div class="wy-side-nav-search" >
-            <a href="index.html" class="icon icon-home"> GEN DAQ API - Python Driver
+
+          
+          
+          <a href="index.html" class="icon icon-home">
+            GEN DAQ API - Python Driver
           </a>
 <div role="search">
   <form id="rtd-search-form" class="wy-form" action="search.html" method="get">
-    <input type="text" name="q" placeholder="Search docs" />
+    <input type="text" name="q" placeholder="Search docs" aria-label="Search docs" />
     <input type="hidden" name="check_keywords" value="yes" />
     <input type="hidden" name="area" value="default" />
   </form>
@@ -47,7 +52,17 @@
 <li class="toctree-l3"><a class="reference internal" href="mainframe.html">Mainframe</a></li>
 <li class="toctree-l3"><a class="reference internal" href="managerecording.html">Manage recordings</a></li>
 <li class="toctree-l3"><a class="reference internal" href="managemainframe.html">Manage mainframe settings</a></li>
-<li class="toctree-l3 current"><a class="current reference internal" href="#">Recorder</a></li>
+<li class="toctree-l3 current"><a class="current reference internal" href="#">Recorder</a><ul>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_get_recorder_info"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_recorder_info()</span></code></a></li>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_get_recorder_enabled"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_recorder_enabled()</span></code></a></li>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_set_recorder_enabled"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_set_recorder_enabled()</span></code></a></li>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_get_channel_count"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_channel_count()</span></code></a></li>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_get_sample_rate"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_sample_rate()</span></code></a></li>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_set_sample_rate"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_set_sample_rate()</span></code></a></li>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_get_digital_output"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_digital_output()</span></code></a></li>
+<li class="toctree-l4"><a class="reference internal" href="#ghsapi.ghsapi.GHS.ghs_set_digital_output"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_set_digital_output()</span></code></a></li>
+</ul>
+</li>
 </ul>
 </li>
 <li class="toctree-l2"><a class="reference internal" href="releasenotes.html#version-1-1">Version 1.1</a></li>
@@ -69,9 +84,9 @@
         <div class="rst-content">
           <div role="navigation" aria-label="Page navigation">
   <ul class="wy-breadcrumbs">
-      <li><a href="index.html" class="icon icon-home"></a> &raquo;</li>
-          <li><a href="ghspyapi.html">API Functions</a> &raquo;</li>
-      <li>Recorder</li>
+      <li><a href="index.html" class="icon icon-home" aria-label="Home"></a></li>
+          <li class="breadcrumb-item"><a href="ghspyapi.html">API Functions</a></li>
+      <li class="breadcrumb-item active">Recorder</li>
       <li class="wy-breadcrumbs-aside">
             <a href="_sources/recorder.rst.txt" rel="nofollow"> View page source</a>
       </li>
@@ -82,7 +97,7 @@
            <div itemprop="articleBody">
              
   <section id="recorder">
-<h1>Recorder<a class="headerlink" href="#recorder" title="Permalink to this headline"></a></h1>
+<h1>Recorder<a class="headerlink" href="#recorder" title="Permalink to this heading"></a></h1>
 <p>Recorder related API functions.</p>
 <dl class="py method">
 <dt class="sig sig-object py" id="ghsapi.ghsapi.GHS.ghs_get_recorder_info">
@@ -94,10 +109,10 @@ <h1>Recorder<a class="headerlink" href="#recorder" title="Permalink to this head
 <p><em>This method can be called by multiple connected clients at same
 time.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><p><strong>slot_id</strong> – The slot containing the recorder</p>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return status</p></li>
 <li><p>recorder_type - The type of the recorder</p></li>
@@ -117,10 +132,10 @@ <h1>Recorder<a class="headerlink" href="#recorder" title="Permalink to this head
 <p><em>This method can be called by multiple connected clients at same
 time.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><p><strong>slot_id</strong> – The slot containing the recorder</p>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return status</p></li>
 <li><p>GHSEnableDisable - The recorder enabled status</p></li>
@@ -139,13 +154,13 @@ <h1>Recorder<a class="headerlink" href="#recorder" title="Permalink to this head
 with the most privileges order (Privileges order: 1- Perception,
 2- GenDaq, 3- Other)</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>enabled</strong> – Set to GHS_Enable/GHS_Disable to enable/disable</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return status</p></li>
 </ul>
@@ -161,10 +176,10 @@ <h1>Recorder<a class="headerlink" href="#recorder" title="Permalink to this head
 <p><em>This method can be called by multiple connected clients at same
 time.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><p><strong>slot_id</strong> – The slot containing the recorder</p>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return status</p></li>
 <li><p>channel_count - The number of channels for the recorder</p></li>
@@ -181,10 +196,10 @@ <h1>Recorder<a class="headerlink" href="#recorder" title="Permalink to this head
 <p><em>This method can be called by multiple connected clients at same
 time.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><p><strong>slot_id</strong> – The slot containing the recorder</p>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return status</p></li>
 <li><p>sample_rate - in samples per second</p></li>
@@ -207,13 +222,13 @@ <h1>Recorder<a class="headerlink" href="#recorder" title="Permalink to this head
 with the most privileges order (Privileges order: 1- Perception,
 2- GenDaq, 3- Other)</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>sample_rate</strong> – In samples per second.</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return status</p></li>
 </ul>
@@ -230,13 +245,13 @@ <h1>Recorder<a class="headerlink" href="#recorder" title="Permalink to this head
 <p><em>This method can be called by multiple connected clients at same
 time.</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>digital_output</strong> – The output number desired.</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return status</p></li>
 <li><p>GHSDigitalOutMode - The digital output mode for that output</p></li>
@@ -255,14 +270,14 @@ <h1>Recorder<a class="headerlink" href="#recorder" title="Permalink to this head
 with the most privileges order (Privileges order: 1- Perception,
 2- GenDaq, 3- Other)</em></p>
 <dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
+<dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>slot_id</strong> – The slot containing the recorder</p></li>
 <li><p><strong>digital_output</strong> – The output number desired.</p></li>
 <li><p><strong>digital_output_mode</strong> – The digital output mode to set</p></li>
 </ul>
 </dd>
-<dt class="field-even">Returns</dt>
+<dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p>GHSReturnValue - API return status</p></li>
 </ul>
diff --git a/docs/html/releasenotes.html b/docs/html/releasenotes.html
index 444af2d..99bc7b2 100644
--- a/docs/html/releasenotes.html
+++ b/docs/html/releasenotes.html
@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html class="writer-html5" lang="en" >
 <head>
-  <meta charset="utf-8" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
+  <meta charset="utf-8" /><meta name="generator" content="Docutils 0.18.1: http://docutils.sourceforge.net/" />
 
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <title>Release Notes &mdash; GEN DAQ API - Python Driver 1.1 documentation</title>
@@ -11,15 +11,16 @@
     <script src="_static/js/html5shiv.min.js"></script>
   <![endif]-->
   
-        <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
         <script src="_static/jquery.js"></script>
-        <script src="_static/underscore.js"></script>
+        <script src="_static/_sphinx_javascript_frameworks_compat.js"></script>
+        <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
         <script src="_static/doctools.js"></script>
+        <script src="_static/sphinx_highlight.js"></script>
     <script src="_static/js/theme.js"></script>
     <link rel="index" title="Index" href="genindex.html" />
     <link rel="search" title="Search" href="search.html" />
     <link rel="next" title="Remarks" href="remarks.html" />
-    <link rel="prev" title="Timer/Counter" href="channeltimer.html" /> 
+    <link rel="prev" title="FieldBus" href="fieldbus.html" /> 
 </head>
 
 <body class="wy-body-for-nav"> 
@@ -27,11 +28,15 @@
     <nav data-toggle="wy-nav-shift" class="wy-nav-side">
       <div class="wy-side-scroll">
         <div class="wy-side-nav-search" >
-            <a href="index.html" class="icon icon-home"> GEN DAQ API - Python Driver
+
+          
+          
+          <a href="index.html" class="icon icon-home">
+            GEN DAQ API - Python Driver
           </a>
 <div role="search">
   <form id="rtd-search-form" class="wy-form" action="search.html" method="get">
-    <input type="text" name="q" placeholder="Search docs" />
+    <input type="text" name="q" placeholder="Search docs" aria-label="Search docs" />
     <input type="hidden" name="check_keywords" value="yes" />
     <input type="hidden" name="area" value="default" />
   </form>
@@ -72,8 +77,8 @@
         <div class="rst-content">
           <div role="navigation" aria-label="Page navigation">
   <ul class="wy-breadcrumbs">
-      <li><a href="index.html" class="icon icon-home"></a> &raquo;</li>
-      <li>Release Notes</li>
+      <li><a href="index.html" class="icon icon-home" aria-label="Home"></a></li>
+      <li class="breadcrumb-item active">Release Notes</li>
       <li class="wy-breadcrumbs-aside">
             <a href="_sources/releasenotes.rst.txt" rel="nofollow"> View page source</a>
       </li>
@@ -84,24 +89,77 @@
            <div itemprop="articleBody">
              
   <section id="release-notes">
-<h1>Release Notes<a class="headerlink" href="#release-notes" title="Permalink to this headline"></a></h1>
+<h1>Release Notes<a class="headerlink" href="#release-notes" title="Permalink to this heading"></a></h1>
 <section id="version-1-0">
-<h2>Version 1.0<a class="headerlink" href="#version-1-0" title="Permalink to this headline"></a></h2>
+<h2>Version 1.0<a class="headerlink" href="#version-1-0" title="Permalink to this heading"></a></h2>
 <p>This is the release 1.0 of the GEN DAQ API - Python Driver</p>
 <p><strong>Features included:</strong></p>
 <div class="toctree-wrapper compound">
 <ul>
-<li class="toctree-l1"><a class="reference internal" href="connections.html">Connections</a></li>
-<li class="toctree-l1"><a class="reference internal" href="acquisition.html">Acquisition control</a></li>
-<li class="toctree-l1"><a class="reference internal" href="mainframe.html">Mainframe</a></li>
-<li class="toctree-l1"><a class="reference internal" href="managerecording.html">Manage recordings</a></li>
-<li class="toctree-l1"><a class="reference internal" href="managemainframe.html">Manage mainframe settings</a></li>
-<li class="toctree-l1"><a class="reference internal" href="recorder.html">Recorder</a></li>
+<li class="toctree-l1"><a class="reference internal" href="connections.html">Connections</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="connections.html#ghsapi.ghsapi.GHS.ghs_connect"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_connect()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="connections.html#ghsapi.ghsapi.GHS.ghs_disconnect"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_disconnect()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="connections.html#ghsapi.ghsapi.GHS.ghs_get_client_api_version"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_client_api_version()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="connections.html#ghsapi.ghsapi.GHS.ghs_get_current_access"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_current_access()</span></code></a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="acquisition.html">Acquisition control</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="acquisition.html#ghsapi.ghsapi.GHS.ghs_start_preview"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_start_preview()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="acquisition.html#ghsapi.ghsapi.GHS.ghs_stop_preview"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_stop_preview()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="acquisition.html#ghsapi.ghsapi.GHS.ghs_start_recording"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_start_recording()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="acquisition.html#ghsapi.ghsapi.GHS.ghs_pause_recording"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_pause_recording()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="acquisition.html#ghsapi.ghsapi.GHS.ghs_resume_recording"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_resume_recording()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="acquisition.html#ghsapi.ghsapi.GHS.ghs_stop_recording"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_stop_recording()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="acquisition.html#ghsapi.ghsapi.GHS.ghs_trigger"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_trigger()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="acquisition.html#ghsapi.ghsapi.GHS.ghs_get_acquisition_state"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_acquisition_state()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="acquisition.html#ghsapi.ghsapi.GHS.ghs_get_acquisition_time"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_acquisition_time()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="acquisition.html#ghsapi.ghsapi.GHS.ghs_get_acquisition_start_time"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_acquisition_start_time()</span></code></a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="mainframe.html">Mainframe</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="mainframe.html#ghsapi.ghsapi.GHS.ghs_identify"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_identify()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="mainframe.html#ghsapi.ghsapi.GHS.ghs_get_disk_space"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_disk_space()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="mainframe.html#ghsapi.ghsapi.GHS.ghs_get_sync_status"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_sync_status()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="mainframe.html#ghsapi.ghsapi.GHS.ghs_get_slot_count"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_slot_count()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="mainframe.html#ghsapi.ghsapi.GHS.ghs_get_user_mode"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_user_mode()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="mainframe.html#ghsapi.ghsapi.GHS.ghs_set_user_mode"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_set_user_mode()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="mainframe.html#ghsapi.ghsapi.GHS.ghs_get_mainframe_info"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_mainframe_info()</span></code></a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="managerecording.html">Manage recordings</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="managerecording.html#ghsapi.ghsapi.GHS.ghs_get_storage_location"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_storage_location()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="managerecording.html#ghsapi.ghsapi.GHS.ghs_set_storage_location"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_set_storage_location()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="managerecording.html#ghsapi.ghsapi.GHS.ghs_get_recording_name"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_recording_name()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="managerecording.html#ghsapi.ghsapi.GHS.ghs_set_recording_name"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_set_recording_name()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="managerecording.html#ghsapi.ghsapi.GHS.ghs_delete_last_recording"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_delete_last_recording()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="managerecording.html#ghsapi.ghsapi.GHS.ghs_delete_all_recordings"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_delete_all_recordings()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="managerecording.html#ghsapi.ghsapi.GHS.ghs_get_high_low_rate_storage_enabled"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_high_low_rate_storage_enabled()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="managerecording.html#ghsapi.ghsapi.GHS.ghs_set_high_low_rate_storage_enabled"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_set_high_low_rate_storage_enabled()</span></code></a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="managemainframe.html">Manage mainframe settings</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="managemainframe.html#ghsapi.ghsapi.GHS.ghs_get_current_settings"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_current_settings()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="managemainframe.html#ghsapi.ghsapi.GHS.ghs_set_current_settings"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_set_current_settings()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="managemainframe.html#ghsapi.ghsapi.GHS.ghs_persist_current_settings"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_persist_current_settings()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="managemainframe.html#ghsapi.ghsapi.GHS.ghs_apply_persisted_settings"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_apply_persisted_settings()</span></code></a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="recorder.html">Recorder</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="recorder.html#ghsapi.ghsapi.GHS.ghs_get_recorder_info"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_recorder_info()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="recorder.html#ghsapi.ghsapi.GHS.ghs_get_recorder_enabled"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_recorder_enabled()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="recorder.html#ghsapi.ghsapi.GHS.ghs_set_recorder_enabled"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_set_recorder_enabled()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="recorder.html#ghsapi.ghsapi.GHS.ghs_get_channel_count"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_channel_count()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="recorder.html#ghsapi.ghsapi.GHS.ghs_get_sample_rate"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_sample_rate()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="recorder.html#ghsapi.ghsapi.GHS.ghs_set_sample_rate"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_set_sample_rate()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="recorder.html#ghsapi.ghsapi.GHS.ghs_get_digital_output"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_get_digital_output()</span></code></a></li>
+<li class="toctree-l2"><a class="reference internal" href="recorder.html#ghsapi.ghsapi.GHS.ghs_set_digital_output"><code class="docutils literal notranslate"><span class="pre">GHS.ghs_set_digital_output()</span></code></a></li>
+</ul>
+</li>
 </ul>
 </div>
 </section>
 <section id="version-1-1">
-<h2>Version 1.1<a class="headerlink" href="#version-1-1" title="Permalink to this headline"></a></h2>
+<h2>Version 1.1<a class="headerlink" href="#version-1-1" title="Permalink to this heading"></a></h2>
 <p>This is the release 1.1 of the GEN DAQ API - Python Driver</p>
 <p><strong>Features included:</strong></p>
 <div class="toctree-wrapper compound">
@@ -120,7 +178,7 @@ <h2>Version 1.1<a class="headerlink" href="#version-1-1" title="Permalink to thi
            </div>
           </div>
           <footer><div class="rst-footer-buttons" role="navigation" aria-label="Footer">
-        <a href="channeltimer.html" class="btn btn-neutral float-left" title="Timer/Counter" accesskey="p" rel="prev"><span class="fa fa-arrow-circle-left" aria-hidden="true"></span> Previous</a>
+        <a href="fieldbus.html" class="btn btn-neutral float-left" title="FieldBus" accesskey="p" rel="prev"><span class="fa fa-arrow-circle-left" aria-hidden="true"></span> Previous</a>
         <a href="remarks.html" class="btn btn-neutral float-right" title="Remarks" accesskey="n" rel="next">Next <span class="fa fa-arrow-circle-right" aria-hidden="true"></span></a>
     </div>
 
diff --git a/docs/html/remarks.html b/docs/html/remarks.html
index 57a0e0a..6f034fa 100644
--- a/docs/html/remarks.html
+++ b/docs/html/remarks.html
@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html class="writer-html5" lang="en" >
 <head>
-  <meta charset="utf-8" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
+  <meta charset="utf-8" /><meta name="generator" content="Docutils 0.18.1: http://docutils.sourceforge.net/" />
 
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <title>Remarks &mdash; GEN DAQ API - Python Driver 1.1 documentation</title>
@@ -11,10 +11,11 @@
     <script src="_static/js/html5shiv.min.js"></script>
   <![endif]-->
   
-        <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
         <script src="_static/jquery.js"></script>
-        <script src="_static/underscore.js"></script>
+        <script src="_static/_sphinx_javascript_frameworks_compat.js"></script>
+        <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
         <script src="_static/doctools.js"></script>
+        <script src="_static/sphinx_highlight.js"></script>
     <script src="_static/js/theme.js"></script>
     <link rel="index" title="Index" href="genindex.html" />
     <link rel="search" title="Search" href="search.html" />
@@ -26,11 +27,15 @@
     <nav data-toggle="wy-nav-shift" class="wy-nav-side">
       <div class="wy-side-scroll">
         <div class="wy-side-nav-search" >
-            <a href="index.html" class="icon icon-home"> GEN DAQ API - Python Driver
+
+          
+          
+          <a href="index.html" class="icon icon-home">
+            GEN DAQ API - Python Driver
           </a>
 <div role="search">
   <form id="rtd-search-form" class="wy-form" action="search.html" method="get">
-    <input type="text" name="q" placeholder="Search docs" />
+    <input type="text" name="q" placeholder="Search docs" aria-label="Search docs" />
     <input type="hidden" name="check_keywords" value="yes" />
     <input type="hidden" name="area" value="default" />
   </form>
@@ -56,8 +61,8 @@
         <div class="rst-content">
           <div role="navigation" aria-label="Page navigation">
   <ul class="wy-breadcrumbs">
-      <li><a href="index.html" class="icon icon-home"></a> &raquo;</li>
-      <li>Remarks</li>
+      <li><a href="index.html" class="icon icon-home" aria-label="Home"></a></li>
+      <li class="breadcrumb-item active">Remarks</li>
       <li class="wy-breadcrumbs-aside">
             <a href="_sources/remarks.rst.txt" rel="nofollow"> View page source</a>
       </li>
@@ -68,7 +73,7 @@
            <div itemprop="articleBody">
              
   <section id="remarks">
-<h1>Remarks<a class="headerlink" href="#remarks" title="Permalink to this headline"></a></h1>
+<h1>Remarks<a class="headerlink" href="#remarks" title="Permalink to this heading"></a></h1>
 <ul class="simple">
 <li><p>It is not possible to move/copy recordings from the local mainframe storage to a PC storage location via the GEN DAQ API. If you want to do this you have to enable the remote access to the internal disk. This can be done using Perception via the Mainframe Settings dialog. In this help file you can find how to do this. Look for GEN DAQ Remote Access item.</p></li>
 <li><p>The GEN DAQ API is supported by the following mainframes: GEN3i, GEN3t, GEN7i, GEN7tA, GEN7i and GEN2tB</p></li>
diff --git a/docs/html/search.html b/docs/html/search.html
index 689a788..ad6f18a 100644
--- a/docs/html/search.html
+++ b/docs/html/search.html
@@ -11,10 +11,11 @@
     <script src="_static/js/html5shiv.min.js"></script>
   <![endif]-->
   
-        <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
         <script src="_static/jquery.js"></script>
-        <script src="_static/underscore.js"></script>
+        <script src="_static/_sphinx_javascript_frameworks_compat.js"></script>
+        <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script>
         <script src="_static/doctools.js"></script>
+        <script src="_static/sphinx_highlight.js"></script>
     <script src="_static/js/theme.js"></script>
     <script src="_static/searchtools.js"></script>
     <script src="_static/language_data.js"></script>
@@ -27,11 +28,15 @@
     <nav data-toggle="wy-nav-shift" class="wy-nav-side">
       <div class="wy-side-scroll">
         <div class="wy-side-nav-search" >
-            <a href="index.html" class="icon icon-home"> GEN DAQ API - Python Driver
+
+          
+          
+          <a href="index.html" class="icon icon-home">
+            GEN DAQ API - Python Driver
           </a>
 <div role="search">
   <form id="rtd-search-form" class="wy-form" action="#" method="get">
-    <input type="text" name="q" placeholder="Search docs" />
+    <input type="text" name="q" placeholder="Search docs" aria-label="Search docs" />
     <input type="hidden" name="check_keywords" value="yes" />
     <input type="hidden" name="area" value="default" />
   </form>
@@ -57,8 +62,8 @@
         <div class="rst-content">
           <div role="navigation" aria-label="Page navigation">
   <ul class="wy-breadcrumbs">
-      <li><a href="index.html" class="icon icon-home"></a> &raquo;</li>
-      <li>Search</li>
+      <li><a href="index.html" class="icon icon-home" aria-label="Home"></a></li>
+      <li class="breadcrumb-item active">Search</li>
       <li class="wy-breadcrumbs-aside">
       </li>
   </ul>
diff --git a/docs/html/searchindex.js b/docs/html/searchindex.js
index 08345e3..be435e8 100644
--- a/docs/html/searchindex.js
+++ b/docs/html/searchindex.js
@@ -1 +1 @@
-Search.setIndex({docnames:["acquisition","channel","channelanalog","channeltimer","connections","ghspyapi","index","introduction","mainframe","managemainframe","managerecording","recorder","releasenotes","remarks"],envversion:{"sphinx.domains.c":2,"sphinx.domains.changeset":1,"sphinx.domains.citation":1,"sphinx.domains.cpp":4,"sphinx.domains.index":1,"sphinx.domains.javascript":2,"sphinx.domains.math":2,"sphinx.domains.python":3,"sphinx.domains.rst":2,"sphinx.domains.std":2,"sphinx.ext.viewcode":1,sphinx:56},filenames:["acquisition.rst","channel.rst","channelanalog.rst","channeltimer.rst","connections.rst","ghspyapi.rst","index.rst","introduction.rst","mainframe.rst","managemainframe.rst","managerecording.rst","recorder.rst","releasenotes.rst","remarks.rst"],objects:{"ghsapi.ghsapi.GHS":[[9,0,1,"","ghs_apply_persisted_settings"],[2,0,1,"","ghs_cmd_auto_range_now"],[1,0,1,"","ghs_cmd_zeroing"],[4,0,1,"","ghs_connect"],[10,0,1,"","ghs_delete_all_recordings"],[10,0,1,"","ghs_delete_last_recording"],[4,0,1,"","ghs_disconnect"],[0,0,1,"","ghs_get_acquisition_start_time"],[0,0,1,"","ghs_get_acquisition_state"],[0,0,1,"","ghs_get_acquisition_time"],[2,0,1,"","ghs_get_amplifier_mode"],[2,0,1,"","ghs_get_auto_range"],[2,0,1,"","ghs_get_channel_cal_info"],[11,0,1,"","ghs_get_channel_count"],[1,0,1,"","ghs_get_channel_name"],[1,0,1,"","ghs_get_channel_storage_enabled"],[1,0,1,"","ghs_get_channel_type"],[4,0,1,"","ghs_get_client_api_version"],[4,0,1,"","ghs_get_current_access"],[9,0,1,"","ghs_get_current_settings"],[11,0,1,"","ghs_get_digital_output"],[8,0,1,"","ghs_get_disk_space"],[2,0,1,"","ghs_get_excitation"],[2,0,1,"","ghs_get_filter_type_and_frequency"],[10,0,1,"","ghs_get_high_low_rate_storage_enabled"],[2,0,1,"","ghs_get_input_coupling"],[8,0,1,"","ghs_get_mainframe_info"],[11,0,1,"","ghs_get_recorder_enabled"],[11,0,1,"","ghs_get_recorder_info"],[10,0,1,"","ghs_get_recording_name"],[11,0,1,"","ghs_get_sample_rate"],[2,0,1,"","ghs_get_signal_coupling"],[8,0,1,"","ghs_get_slot_count"],[2,0,1,"","ghs_get_span_and_offset"],[10,0,1,"","ghs_get_storage_location"],[8,0,1,"","ghs_get_sync_status"],[2,0,1,"","ghs_get_technical_units"],[3,0,1,"","ghs_get_timer_counter_gate_time"],[3,0,1,"","ghs_get_timer_counter_mode"],[3,0,1,"","ghs_get_timer_counter_range"],[2,0,1,"","ghs_get_trigger_settings"],[8,0,1,"","ghs_get_user_mode"],[8,0,1,"","ghs_identify"],[0,0,1,"","ghs_pause_recording"],[9,0,1,"","ghs_persist_current_settings"],[0,0,1,"","ghs_resume_recording"],[2,0,1,"","ghs_set_amplifier_mode"],[2,0,1,"","ghs_set_auto_range"],[1,0,1,"","ghs_set_channel_name"],[1,0,1,"","ghs_set_channel_storage_enabled"],[9,0,1,"","ghs_set_current_settings"],[11,0,1,"","ghs_set_digital_output"],[2,0,1,"","ghs_set_excitation"],[2,0,1,"","ghs_set_filter_type_and_frequency"],[10,0,1,"","ghs_set_high_low_rate_storage_enabled"],[2,0,1,"","ghs_set_input_coupling"],[11,0,1,"","ghs_set_recorder_enabled"],[10,0,1,"","ghs_set_recording_name"],[11,0,1,"","ghs_set_sample_rate"],[2,0,1,"","ghs_set_signal_coupling"],[2,0,1,"","ghs_set_span_and_offset"],[10,0,1,"","ghs_set_storage_location"],[2,0,1,"","ghs_set_technical_units"],[3,0,1,"","ghs_set_timer_counter_gate_time"],[3,0,1,"","ghs_set_timer_counter_mode"],[3,0,1,"","ghs_set_timer_counter_range"],[2,0,1,"","ghs_set_trigger_settings"],[8,0,1,"","ghs_set_user_mode"],[0,0,1,"","ghs_start_preview"],[0,0,1,"","ghs_start_recording"],[0,0,1,"","ghs_stop_preview"],[0,0,1,"","ghs_stop_recording"],[0,0,1,"","ghs_trigger"]]},objnames:{"0":["py","method","Python method"]},objtypes:{"0":"py:method"},terms:{"0":6,"1":[1,2,3,6,11],"2":[1,2,3,11],"3":[1,2,3,11],"8":[1,2,8,10,11],"8006":4,"byte":9,"case":4,"default":[2,3],"do":13,"float":[0,2,3,8,11],"function":[0,2,3,4,6,8,9,10,11,12,13],"int":[0,1,2,3,4,8,9,10,11],"return":[0,1,2,3,4,8,9,10,11],A:[1,9,10,11],As:9,For:4,If:[2,3,4,11,13],In:[9,11,13],It:13,The:[0,1,2,3,4,6,7,8,9,10,11,13],These:[6,7],absolut:0,ac:2,ac_externalprob:2,ac_frequ:2,ac_rm:2,ac_truerm:2,accept:[1,2,3,8,10,11],access:[4,13],acquir:[2,11],acquisit:[5,6,7,12],acquisition_tim:0,acquist:0,adapt:2,address:4,alarm:11,alik:[7,13],all:[5,6,7,10],alloc:9,amount:9,amplifi:2,amplifier_mod:2,an:[2,4],analog:[1,7],anglebidirect:3,anglebidirectionalwithrefpo:3,anglequadratur:3,anglequadraturewithrefpo:3,angleunidirect:3,angleunidirectionalwithrefpo:3,ani:[2,4,9,11],api:[0,1,2,3,4,7,8,9,10,11,12,13],appli:9,applic:[2,6,7],ar:[2,3,8,9,10,11],asynchron:10,auto:2,auto_range_en:2,auto_range_tim:2,avail:[2,5,8],bandpass:2,base:[1,2,3,6,7,10],basic:[2,7],basicsensor:2,been:2,befor:[0,1,2,3,8,9,10,11],being:9,bessel:2,bessel_aa:2,blob:9,blob_siz:9,bool:8,boot:9,bridg:2,butterworth:2,butterworth_aa:2,calibr:2,calibration_date_tim:2,calibration_lab:2,calibrationdatetim:2,calibrationlab:2,call:[0,1,2,3,8,9,10,11],caller:9,can:[0,1,2,3,4,6,7,9,11,13],cannot:0,care:7,chang:4,channel:[2,3,5,6,7,11,12],channel_count:11,channel_index:[1,2,3],channel_nam:1,charg:2,client:[1,2,3,4,11],client_api_vers:4,command:[0,2],concurr:4,conduct:2,configur:[7,9],connect:[0,1,2,3,5,6,8,11,12],contain:[1,2,3,9,10,11],continu:[7,8],control:[5,6,7,12],copi:13,correct:[3,7,9],countbidirect:3,counter:[1,7],countquadratur:3,countunidirect:3,coupl:2,current4_20:2,current:[0,2,4,7,9],current_strob:2,dai:0,daq:[4,7,12,13],data:[7,10,13],date:2,dc:2,dc_externalprob:2,dc_frequenc:2,dc_rm:2,dc_truerm:2,defin:4,delet:10,desir:[1,2,3,8,10,11],determin:[1,2,3,8,11],dialog:13,differenti:2,digit:11,digital_output:11,digital_output_mod:11,direct:2,disabl:[1,2,8,10,11],disconnect:4,disk:[8,13],doe:13,don:13,done:13,doubleprecis:2,driver:[7,12],drop:4,dual:[2,8],dualwindow:2,e:[1,2,3,10,11],effect:2,ellipt:2,enabl:[1,2,8,10,11,13],encod:[1,2,8,10,11],ensur:9,error:[0,4],establish:4,even:[6,7],exampl:4,excit:2,excitation_typ:2,excitation_valu:2,execut:0,ezero:1,fallingedg:2,featur:[9,12],fieldbu:[7,13],file:[6,7,10,13],filter:2,filter_typ:2,find:13,fir3db:2,fir:2,firmwar:[8,11],firmware_vers:[8,11],firmwarevers:[8,11],first:[1,10,11],flag:[8,10],floatingdifferenti:2,follow:[7,13],frequenc:2,frequencybidirect:3,frequencyquadratur:3,frequencyunidirect:3,from:[1,2,3,4,10,11,13],g:[1,2,10,11],gate:3,gate_tim:3,gb:8,gen2tb:13,gen3i:13,gen3t:13,gen7i:13,gen7ta:13,gen:[4,7,12,13],gendaq:[1,2,3,11],gener:[0,7],get:[7,8],gh:[0,1,2,3,4,8,9,10,11],ghs__get_aplifier_mod:7,ghs__get_current_set:7,ghs__get_recorder_en:7,ghs__get_sample_r:7,ghs__set_channel_nam:7,ghs__set_current_set:7,ghs__set_sample_r:7,ghs__trigger:7,ghs_apply_persisted_set:9,ghs_cmd_auto_range_now:2,ghs_cmd_zero:1,ghs_connect:4,ghs_delete_all_record:10,ghs_delete_last_record:10,ghs_disabl:11,ghs_disconnect:4,ghs_enabl:11,ghs_get_acquisition_st:0,ghs_get_acquisition_start_tim:0,ghs_get_acquisition_tim:0,ghs_get_amplifier_mod:2,ghs_get_auto_rang:2,ghs_get_channel_cal_info:2,ghs_get_channel_count:[7,11],ghs_get_channel_nam:[1,7],ghs_get_channel_storage_en:[1,7],ghs_get_channel_typ:1,ghs_get_client_api_vers:4,ghs_get_continuous_lead_out_tim:7,ghs_get_continuous_recording_mod:7,ghs_get_current_access:4,ghs_get_current_set:9,ghs_get_digital_output:11,ghs_get_disk_spac:8,ghs_get_excit:2,ghs_get_filter_type_and_frequ:2,ghs_get_high_low_rate_storage_en:10,ghs_get_input_coupl:2,ghs_get_mainframe_info:8,ghs_get_recorder_en:11,ghs_get_recorder_info:11,ghs_get_recorder_inform:7,ghs_get_recording_nam:10,ghs_get_sample_r:11,ghs_get_signal_coupl:2,ghs_get_slot_count:8,ghs_get_span_and_offset:[2,7],ghs_get_storage_loc:10,ghs_get_sweep_length:7,ghs_get_sweep_recording_mod:7,ghs_get_sync_statu:8,ghs_get_technical_unit:2,ghs_get_timer_counter_gate_tim:3,ghs_get_timer_counter_mod:[3,7],ghs_get_timer_counter_rang:[3,7],ghs_get_trigger_set:2,ghs_get_user_mod:8,ghs_identifi:8,ghs_initiate_field_bus_data_transf:7,ghs_pause_record:0,ghs_persist_current_set:9,ghs_read_next_snapshot:7,ghs_receive_field_bus_data:7,ghs_resume_record:0,ghs_set_amplifier_mod:2,ghs_set_aplifier_mod:7,ghs_set_auto_rang:2,ghs_set_channel_nam:1,ghs_set_channel_storage_en:[1,7],ghs_set_continuous_lead_out_tim:7,ghs_set_continuous_recording_mod:7,ghs_set_current_set:9,ghs_set_digital_output:11,ghs_set_excit:2,ghs_set_filter_type_and_frequ:2,ghs_set_high_low_rate_storage_en:10,ghs_set_input_coupl:2,ghs_set_recorder_en:11,ghs_set_recording_nam:10,ghs_set_sample_r:11,ghs_set_signal_coupl:2,ghs_set_span_and_offset:[2,7],ghs_set_storage_loc:10,ghs_set_sweep_length:7,ghs_set_sweep_recording_mod:7,ghs_set_technical_unit:2,ghs_set_timer_counter_gate_tim:3,ghs_set_timer_counter_mod:[3,7],ghs_set_timer_counter_rang:[3,7],ghs_set_trigger_set:2,ghs_set_user_mod:8,ghs_start_preview:0,ghs_start_record:0,ghs_stop_field_bus_data_transf:7,ghs_stop_preview:0,ghs_stop_record:0,ghs_trigger:0,ghsaccess:4,ghsacquisitionst:0,ghsamplifiermod:2,ghschanneltyp:1,ghsdigitaloutmod:11,ghsenabledis:[1,2,10,11],ghsexcitationtyp:2,ghsfiltertyp:2,ghsinputcoupl:2,ghsreturnvalu:[0,1,2,3,4,8,9,10,11],ghsreturnvalue_apimismatch:4,ghssignalcoupl:2,ghsstorageloc:10,ghssyncstatu:8,ghstimercountermod:3,ghstriggermod:2,ghsusermod:8,gnd:2,grant:4,ha:[2,4],handl:4,have:[2,13],hbm:[6,7],help:[6,7,13],hertz:2,high:[10,11],high_rate_en:10,how:13,hysteresi:2,hz:2,i:3,icp:2,id:[2,3,11],identif:8,identifi:8,identity_flag:8,idl:[0,1,2,3,8,9,10,11],iir:2,illeg:3,includ:12,index:[1,2,3,10],indic:10,inform:[2,8,11],input:2,input_coupl:2,integr:13,intern:[8,13],introduct:6,ip:4,ip_address:4,ipv4:4,iscsi1:10,iscsi2:10,issu:0,item:13,laboratori:2,last:10,level:2,local1:10,local2:10,local:[0,8,10,13],locat:[0,8,10,13],look:13,low:[10,11],low_rate_en:10,lower:3,lower_valu:3,lowervalu:3,made:13,mainfram:[0,4,5,6,7,10,12,13],mainframe_nam:8,mainframe_typ:8,mainframenam:8,mainframetyp:8,manag:[5,6,12],manual:7,map:9,memori:9,mention:10,method:[1,2,3,9,11],microsoft:[6,7],midnight:0,might:[4,9],mode:[0,2,3,7,8,11],modul:[5,12],most:[1,2,3,6,7,10,11],move:13,multipl:[1,2,3,11],multipli:2,must:[2,10],name:[0,1,8,10,11],nearest:[2,3,11],need:[0,1,2,3,4,8,9,10,11],next:10,none:[0,1,2,3,8,9,10,11],note:[0,6,8],number:[0,4,8,11],offset:2,often:[6,7],onli:[0,1,2,3,11,13],option:2,order:[1,2,3,11],other:[1,2,3,11],output1:11,output2:11,output:11,overwrit:[2,9,11],paramet:[1,2,3,4,8,9,10,11],paus:[0,7],pc:13,per:11,percept:[1,2,3,4,6,7,9,11,13],perform:1,permiss:4,persist:9,pointer:9,port:4,port_num:4,possibl:[3,13],power:2,power_verification_date_tim:2,power_verification_lab:2,powerverificationdatetim:2,powerverificationlab:2,practic:[6,7],predefin:7,preview:[0,7],previous:[2,9,11],primari:2,primary_level:2,privileg:[1,2,3,11],process:[1,2,3,11],python:[7,12],quadprecis:2,qualifierbas:2,qualifierdu:2,rang:[2,3],rate:[7,10,11],re:9,read:[1,2,3,9],readwrit:[1,2,3],recent:10,record:[0,1,2,3,5,6,7,12,13],recorder_nam:11,recorder_typ:11,recordernam:11,recordertyp:11,recording_base_nam:10,recording_index:10,recording_nam:10,refer:2,rel:0,relat:[0,1,2,3,4,8,9,10,11],releas:6,remain:[2,3],remark:6,remot:[10,13],request:[1,2,3,11],requir:4,result:[0,4],resum:[0,7],retriev:[0,2,8,9,10,11],risingedg:2,round:[2,3,11],rpmbidirect:3,rpmquadratur:3,rpmunidirect:3,run:[6,7],s:4,same:[1,2,3,4,11],sampl:[7,11],sample_r:11,second:[0,2,3,11],secondari:2,secondary_level:2,sequenti:2,seri:[6,7],serial:[8,11],serial_numb:[8,11],serialnumb:[8,11],set:[0,1,2,3,5,6,7,8,10,11,12,13],shot:2,should:10,sigmadelta:2,sigmadeltawb:2,signal:2,signal_coupl:2,sinc:0,singl:2,singleendedneg:2,singleendedposit:2,singleprecis:2,size:9,slot:[1,2,3,8,10,11],slot_count:8,slot_id:[1,2,3,10,11],softwar:7,sound:8,sourc:[0,1,2,3,4,8,9,10,11],space:8,span:2,specif:1,specifi:[2,3,10,11],start:[0,7],state:[0,7],statu:[0,1,4,8,9,10,11],stop:[0,7],storag:[0,1,8,10,13],storage_loc:10,store:10,str:[0,1,2,3,4,8,9,10,11],stream:[7,13],successfulli:0,support:[2,3,10,11,13],sweep:[7,8],sync:8,syncchannel:10,syncrealtimeformula:10,system:[0,1,2,3,8,9,10,11],t:13,take:7,task:7,tcp:4,technic:2,tether:[6,7,13],thermocoupl:2,thermoresistor:2,thi:[0,1,2,3,4,8,9,10,11,12,13],time:[0,1,2,3,4,11],timer:[1,7],total:8,trigger:[0,2,7,11],trigger_mod:2,tupl:[0,1,2,3,8,9,10,11],type:[1,2,8,11],unattend:[6,7],unchang:[2,3],unit:2,unzero:1,upon:9,upper:3,upper_valu:3,uppervalu:3,us:[4,6,7,13],user:[2,8],user_mod:8,utf:[1,2,8,10,11],v:2,vale:2,valid:4,valu:[1,2,3,8,10,11],variabl:9,verifi:2,verification_date_tim:2,verification_lab:2,verificationdatetim:2,verificationlab:2,version:[4,6,8,11],via:13,volt:2,voltag:2,voltage_sens:2,voltage_sense_strob:2,voltage_strob:2,want:13,welcom:[6,7],when:[0,4,13],wideband:2,window:[2,6,7],without:[6,7],write:4,writeaccessblock:4,year:0,you:13,zero:[1,2,3],zeroset:2},titles:["Acquisition control","Channel","Analog","Timer/Counter","Connections","API Functions","GEN DAQ API - Python Driver\u2019s documentation","Introduction","Mainframe","Manage mainframe settings","Manage recordings","Recorder","Release Notes","Remarks"],titleterms:{"0":12,"1":12,"function":[1,5],acquisit:0,analog:2,api:[5,6],channel:1,connect:4,content:6,control:0,counter:3,daq:6,document:6,driver:6,gen:6,introduct:7,mainfram:[8,9],manag:[9,10],modul:1,note:12,python:6,record:[10,11],releas:12,remark:13,s:6,set:9,timer:3,version:12}})
\ No newline at end of file
+Search.setIndex({"docnames": ["acquisition", "channel", "channelanalog", "channeltimer", "connections", "fieldbus", "ghspyapi", "index", "introduction", "mainframe", "managemainframe", "managerecording", "recorder", "releasenotes", "remarks"], "filenames": ["acquisition.rst", "channel.rst", "channelanalog.rst", "channeltimer.rst", "connections.rst", "fieldbus.rst", "ghspyapi.rst", "index.rst", "introduction.rst", "mainframe.rst", "managemainframe.rst", "managerecording.rst", "recorder.rst", "releasenotes.rst", "remarks.rst"], "titles": ["Acquisition control", "Channel", "Analog", "Timer/Counter", "Connections", "FieldBus", "API Functions", "GEN DAQ API - Python Driver\u2019s documentation", "Introduction", "Mainframe", "Manage mainframe settings", "Manage recordings", "Recorder", "Release Notes", "Remarks"], "terms": {"relat": [0, 1, 2, 3, 4, 5, 9, 10, 11, 12], "api": [0, 1, 2, 3, 4, 5, 8, 9, 10, 11, 12, 13, 14], "function": [0, 2, 3, 4, 5, 7, 9, 10, 11, 12, 13, 14], "gh": [0, 1, 2, 3, 4, 5, 6, 9, 10, 11, 12, 13], "ghs_start_preview": [0, 6, 13], "str": [0, 1, 2, 3, 4, 5, 9, 10, 11, 12], "sourc": [0, 1, 2, 3, 4, 5, 9, 10, 11, 12], "start": [0, 5, 8], "preview": [0, 8], "mode": [0, 2, 3, 8, 9, 12], "The": [0, 1, 2, 3, 4, 5, 7, 8, 9, 10, 11, 12, 14], "system": [0, 1, 2, 3, 5, 9, 10, 11, 12], "need": [0, 1, 2, 3, 4, 5, 9, 10, 11, 12], "idl": [0, 1, 2, 3, 9, 10, 11, 12], "befor": [0, 1, 2, 3, 5, 9, 10, 11, 12], "call": [0, 1, 2, 3, 5, 9, 10, 11, 12], "thi": [0, 1, 2, 3, 4, 5, 9, 10, 11, 12, 13, 14], "return": [0, 1, 2, 3, 4, 5, 9, 10, 11, 12], "ghsreturnvalu": [0, 1, 2, 3, 4, 5, 9, 10, 11, 12], "statu": [0, 1, 4, 9, 10, 11, 12], "ghs_stop_preview": [0, 6, 13], "stop": [0, 5, 8], "ghs_start_record": [0, 6, 13], "record": [0, 1, 2, 3, 6, 7, 8, 13, 14], "local": [0, 9, 11, 14], "storag": [0, 1, 9, 11, 14], "note": [0, 7, 9], "connect": [0, 1, 2, 3, 5, 6, 7, 9, 12, 13], "mainfram": [0, 4, 5, 6, 7, 8, 11, 13, 14], "gener": [0, 8], "name": [0, 1, 5, 9, 11, 12], "command": [0, 2], "can": [0, 1, 2, 3, 4, 5, 7, 8, 10, 12, 14], "execut": 0, "onli": [0, 1, 2, 3, 12, 14], "successfulli": 0, "when": [0, 4, 5, 14], "i": [0, 1, 2, 3, 4, 5, 7, 8, 10, 11, 12, 13, 14], "set": [0, 1, 2, 3, 5, 6, 7, 8, 9, 11, 12, 13, 14], "ghs_pause_record": [0, 6, 13], "paus": [0, 8], "ghs_resume_record": [0, 6, 13], "resum": [0, 8], "ghs_stop_record": [0, 6, 13], "ghs_trigger": [0, 6, 13], "issu": 0, "trigger": [0, 2, 8, 12], "result": [0, 4, 5], "error": [0, 4, 5], "cannot": 0, "ghs_get_acquisition_st": [0, 6, 13], "tupl": [0, 1, 2, 3, 5, 9, 10, 11, 12], "none": [0, 1, 2, 3, 5, 9, 10, 11, 12], "state": [0, 5, 8], "ghsacquisitionst": 0, "ghs_get_acquisition_tim": [0, 6, 13], "float": [0, 2, 3, 5, 9, 12], "retriev": [0, 2, 5, 9, 10, 11, 12], "current": [0, 2, 4, 8, 10], "time": [0, 1, 2, 3, 4, 12], "rel": [0, 5], "acquist": 0, "acquisition_tim": 0, "second": [0, 2, 3, 12], "ghs_get_acquisition_start_tim": [0, 6, 13], "int": [0, 1, 2, 3, 4, 5, 9, 10, 11, 12], "absolut": 0, "year": 0, "dai": 0, "number": [0, 4, 5, 9, 12], "sinc": 0, "midnight": 0, "locat": [0, 9, 11, 14], "analog": [1, 8], "timer": [1, 8], "counter": [1, 8], "ghs_get_channel_typ": 1, "slot_id": [1, 2, 3, 11, 12], "channel_index": [1, 2, 3], "determin": [1, 2, 3, 9, 12], "type": [1, 2, 9, 12], "read": [1, 2, 3, 10], "method": [1, 2, 3, 5, 10, 12], "multipl": [1, 2, 3, 12], "client": [1, 2, 3, 4, 5, 12], "same": [1, 2, 3, 4, 12], "paramet": [1, 2, 3, 4, 5, 9, 10, 11, 12], "slot": [1, 2, 3, 9, 11, 12], "contain": [1, 2, 3, 5, 10, 11, 12], "zero": [1, 2, 3, 5], "base": [1, 2, 3, 5, 7, 8, 11], "index": [1, 2, 3, 5, 11], "valu": [1, 2, 3, 5, 9, 11, 12], "ghschanneltyp": 1, "ghs_get_channel_nam": [1, 8], "utf": [1, 2, 9, 11, 12], "8": [1, 2, 9, 11, 12], "encod": [1, 2, 9, 11, 12], "channel_nam": 1, "ghs_set_channel_nam": 1, "readwrit": [1, 2, 3], "process": [1, 2, 3, 12], "request": [1, 2, 3, 5, 12], "from": [1, 2, 3, 4, 5, 11, 12, 14], "most": [1, 2, 3, 7, 8, 11, 12], "privileg": [1, 2, 3, 12], "order": [1, 2, 3, 12], "1": [1, 2, 3, 7, 12], "percept": [1, 2, 3, 4, 7, 8, 10, 12, 14], "2": [1, 2, 3, 12], "gendaq": [1, 2, 3, 12], "3": [1, 2, 3, 12], "other": [1, 2, 3, 12], "ghs_get_channel_storage_en": [1, 8], "enabl": [1, 2, 5, 9, 11, 12, 14], "disabl": [1, 2, 9, 11, 12], "ghsenabledis": [1, 2, 11, 12], "ghs_set_channel_storage_en": [1, 8], "desir": [1, 2, 3, 5, 9, 11, 12], "ghs_cmd_zero": 1, "ezero": 1, "perform": 1, "unzero": 1, "specif": [1, 5], "accept": [1, 2, 3, 9, 11, 12], "e": [1, 2, 3, 11, 12], "g": [1, 2, 11, 12], "A": [1, 10, 11, 12], "first": [1, 11, 12], "channel": [2, 3, 6, 7, 8, 12, 13], "ghs_get_trigger_set": 2, "an": [2, 4, 5], "ghstriggermod": 2, "primary_level": 2, "primari": 2, "level": 2, "secondary_level": 2, "secondari": 2, "hysteresi": 2, "direct": 2, "ghs_set_trigger_set": 2, "trigger_mod": 2, "overwrit": [2, 10, 12], "ani": [2, 4, 10, 12], "previous": [2, 10, 12], "specifi": [2, 3, 5, 11, 12], "If": [2, 3, 4, 5, 12, 14], "support": [2, 3, 5, 11, 12, 14], "remain": [2, 3], "unchang": [2, 3], "round": [2, 3, 12], "nearest": [2, 3, 12], "default": [2, 3], "basic": [2, 8], "ghs_get_signal_coupl": 2, "signal": 2, "coupl": 2, "ghssignalcoupl": 2, "ghs_set_signal_coupl": 2, "signal_coupl": 2, "ghs_get_input_coupl": 2, "input": 2, "ghsinputcoupl": 2, "ghs_set_input_coupl": 2, "input_coupl": 2, "ghs_get_span_and_offset": [2, 8], "span": 2, "offset": 2, "user": [2, 5, 9], "unit": [2, 5], "ghs_set_span_and_offset": [2, 8], "adapt": 2, "avail": [2, 5, 6, 9], "option": 2, "ghs_get_filter_type_and_frequ": 2, "filter": 2, "frequenc": 2, "ghsfiltertyp": 2, "hz": [2, 5], "ghs_set_filter_type_and_frequ": 2, "filter_typ": 2, "vale": 2, "bessel": 2, "ghs_get_excit": 2, "excit": 2, "ghsexcitationtyp": 2, "excitation_valu": 2, "voltag": 2, "ghs_set_excit": 2, "excitation_typ": 2, "ghs_get_amplifier_mod": 2, "amplifi": 2, "ghsamplifiermod": 2, "ghs_set_amplifier_mod": 2, "amplifier_mod": 2, "ghs_get_technical_unit": 2, "technic": 2, "multipli": 2, "v": 2, "volt": 2, "hertz": 2, "ghs_set_technical_unit": 2, "must": [2, 5, 11], "ghs_get_auto_rang": 2, "auto": 2, "rang": [2, 3], "auto_range_tim": 2, "ghs_set_auto_rang": 2, "auto_range_en": 2, "ghs_cmd_auto_range_now": 2, "singl": [2, 5], "shot": 2, "acquir": [2, 5, 12], "have": [2, 5, 14], "effect": 2, "ghs_get_channel_cal_info": 2, "calibr": 2, "inform": [2, 9, 12], "calibrationdatetim": 2, "verificationdatetim": 2, "powerverificationdatetim": 2, "calibrationlab": 2, "verificationlab": 2, "powerverificationlab": 2, "ar": [2, 3, 5, 9, 10, 11, 12], "calibration_date_tim": 2, "date": 2, "ha": [2, 4], "been": [2, 5], "verification_date_tim": 2, "verifi": 2, "power_verification_date_tim": 2, "power": 2, "applic": [2, 7, 8], "calibration_lab": 2, "laboratori": 2, "conduct": 2, "verification_lab": 2, "power_verification_lab": 2, "id": [2, 3, 12], "dual": [2, 9], "window": [2, 7, 8], "dualwindow": 2, "sequenti": 2, "qualifierbas": 2, "qualifierdu": 2, "risingedg": 2, "fallingedg": 2, "gnd": 2, "dc": 2, "ac": 2, "dc_rm": 2, "ac_rm": 2, "dc_frequenc": 2, "ac_frequ": 2, "dc_truerm": 2, "ac_truerm": 2, "dc_externalprob": 2, "ac_externalprob": 2, "refer": 2, "zeroset": 2, "singleprecis": 2, "doubleprecis": 2, "quadprecis": 2, "charg": 2, "singleendedposit": 2, "singleendedneg": 2, "differenti": 2, "floatingdifferenti": 2, "butterworth": 2, "ellipt": 2, "fir": 2, "iir": 2, "wideband": 2, "bessel_aa": 2, "butterworth_aa": 2, "sigmadeltawb": 2, "sigmadelta": 2, "bandpass": 2, "fir3db": 2, "voltage_sens": 2, "voltage_strob": 2, "voltage_sense_strob": 2, "current_strob": 2, "bridg": 2, "icp": 2, "thermocoupl": 2, "basicsensor": 2, "current4_20": 2, "thermoresistor": 2, "ghs_get_timer_counter_gate_tim": 3, "gate": 3, "gate_tim": 3, "ghs_set_timer_counter_gate_tim": 3, "ghs_get_timer_counter_mod": [3, 8], "ghstimercountermod": 3, "ghs_set_timer_counter_mod": [3, 8], "rpmunidirect": 3, "ghs_get_timer_counter_rang": [3, 8], "lower_valu": 3, "lower": 3, "upper_valu": 3, "upper": 3, "ghs_set_timer_counter_rang": [3, 8], "illeg": 3, "uppervalu": 3, "lowervalu": 3, "correct": [3, 8, 10], "possibl": [3, 14], "rpmbidirect": 3, "rpmquadratur": 3, "frequencyunidirect": 3, "frequencybidirect": 3, "frequencyquadratur": 3, "countunidirect": 3, "countbidirect": 3, "countquadratur": 3, "anglequadratur": 3, "anglequadraturewithrefpo": 3, "angleunidirect": 3, "angleunidirectionalwithrefpo": 3, "anglebidirect": 3, "anglebidirectionalwithrefpo": 3, "ghs_connect": [4, 6, 13], "ip_address": 4, "port_num": 4, "establish": 4, "ip": 4, "address": 4, "ipv4": 4, "tcp": 4, "port": 4, "defin": 4, "8006": 4, "ghs_disconnect": [4, 6, 13], "disconnect": 4, "handl": 4, "valid": 4, "ghs_get_client_api_vers": [4, 6, 13], "": 4, "version": [4, 7, 9, 12], "us": [4, 5, 7, 8, 14], "ghsreturnvalue_apimismatch": 4, "client_api_vers": 4, "ghs_get_current_access": [4, 6, 13], "access": [4, 14], "permiss": 4, "might": [4, 10], "chang": [4, 5], "For": 4, "exampl": 4, "concurr": 4, "write": [4, 5], "drop": 4, "gen": [4, 8, 13, 14], "daq": [4, 8, 13, 14], "grant": 4, "requir": 4, "writeaccessblock": 4, "case": [4, 5], "ghsaccess": 4, "ghs_get_fieldbus_data_count": [5, 6], "get": [5, 8, 9], "data": [5, 8, 11, 14], "configur": [5, 8, 10], "sent": 5, "through": 5, "field": 5, "bu": 5, "exclud": 5, "timestamp": 5, "data_count": 5, "select": 5, "publish": 5, "ghs_get_fieldbus_data_name_and_unit": [5, 6], "data_index": 5, "give": 5, "ghsgetfieldbusdatacount": 5, "In": [5, 10, 12, 14], "formula": 5, "reserv": 5, "acquisit": [5, 6, 7, 8, 13], "latenc": 5, "code": 5, "ghsreturnvalue_fieldbuserror_noformulasdeploi": 5, "data_nam": 5, "data_unit": 5, "ghs_initiate_fieldbus_data_transf": [5, 6], "update_r": 5, "open": 5, "new": 5, "wait": 5, "onc": 5, "activ": 5, "otherwis": 5, "noth": 5, "present": 5, "you": [5, 14], "back": 5, "ghsreturnvalue_fieldbuserror_notconfigur": 5, "alreadi": 5, "initi": 5, "ghsreturnvalue_fieldbuserror_fieldbusen": 5, "To": 5, "updat": 5, "rate": [5, 8, 11, 12], "stope": 5, "initit": 5, "again": 5, "should": [5, 11], "part": 5, "list": 5, "adjust": 5, "minimum": 5, "distanc": 5, "setup": 5, "includ": [5, 13], "count": 5, "ghs_stop_fieldbus_data_transf": [5, 6], "close": 5, "socket": 5, "dedic": 5, "transfer": 5, "ring": 5, "buffer": 5, "alloc": [5, 10], "delet": [5, 11], "ghs_receive_fieldbus_data": [5, 6], "thread": 5, "so": 5, "mutual": 5, "exclus": 5, "ghsstopfieldbusdatatransf": 5, "loop": 5, "continu": [5, 8, 9], "deliveri": 5, "async": 5, "ghs_read_next_snapshot": [5, 6, 8], "call_typ": 5, "next": [5, 11], "snapshot": 5, "grid": 5, "align": 5, "updater": 5, "argument": 5, "ghsinitiatefieldbusdatatransf": 5, "flag": [5, 9, 11], "control": [5, 6, 7, 8, 13], "receiv": 5, "ghs_blockingcal": 5, "block": 5, "while": 5, "ghs_nonblockingcal": 5, "last": [5, 11], "prefer": 5, "lowest": 5, "cpu": 5, "load": 5, "highest": 5, "troughput": 5, "ghsgetacquisitionstarttim": 5, "overrun": 5, "one": 5, "happen": 5, "ghs_request_fieldbus_snapshot": [5, 6], "datacount": 5, "ghsreturnvalue_systemnotrecord": 5, "allow": 5, "fieldbuserror_unavailablefunction": 5, "actual": 5, "element": 5, "custom": 5, "less": 5, "than": 5, "we": 5, "arrai": 5, "all": [6, 7, 8, 11], "ghs_identifi": [6, 9, 13], "ghs_get_disk_spac": [6, 9, 13], "ghs_get_sync_statu": [6, 9, 13], "ghs_get_slot_count": [6, 9, 13], "ghs_get_user_mod": [6, 9, 13], "ghs_set_user_mod": [6, 9, 13], "ghs_get_mainframe_info": [6, 9, 13], "manag": [6, 7, 13], "ghs_get_storage_loc": [6, 11, 13], "ghs_set_storage_loc": [6, 11, 13], "ghs_get_recording_nam": [6, 11, 13], "ghs_set_recording_nam": [6, 11, 13], "ghs_delete_last_record": [6, 11, 13], "ghs_delete_all_record": [6, 11, 13], "ghs_get_high_low_rate_storage_en": [6, 11, 13], "ghs_set_high_low_rate_storage_en": [6, 11, 13], "ghs_get_current_set": [6, 10, 13], "ghs_set_current_set": [6, 10, 13], "ghs_persist_current_set": [6, 10, 13], "ghs_apply_persisted_set": [6, 10, 13], "ghs_get_recorder_info": [6, 12, 13], "ghs_get_recorder_en": [6, 12, 13], "ghs_set_recorder_en": [6, 12, 13], "ghs_get_channel_count": [6, 8, 12, 13], "ghs_get_sample_r": [6, 12, 13], "ghs_set_sample_r": [6, 12, 13], "ghs_get_digital_output": [6, 12, 13], "ghs_set_digital_output": [6, 12, 13], "modul": [6, 13], "fieldbu": [6, 7, 8, 14], "welcom": [7, 8], "help": [7, 8, 14], "file": [7, 8, 11, 14], "hbm": [7, 8], "seri": [7, 8], "tether": [7, 8, 14], "without": [7, 8], "microsoft": [7, 8], "These": [7, 8], "even": [7, 8], "run": [7, 8], "unattend": [7, 8], "practic": [7, 8], "often": [7, 8], "introduct": 7, "releas": 7, "0": 7, "remark": 7, "python": [8, 13], "driver": [8, 13], "softwar": 8, "take": 8, "care": 8, "follow": [8, 14], "task": 8, "predefin": 8, "ghs__set_current_set": 8, "ghs__get_current_set": 8, "sampl": [8, 12], "ghs__set_sample_r": 8, "ghs__get_sample_r": 8, "manual": 8, "ghs__trigger": 8, "ghs_get_recorder_inform": 8, "ghs__get_recorder_en": 8, "ghs__set_channel_nam": 8, "sweep": [8, 9], "ghs_get_sweep_recording_mod": 8, "ghs_set_sweep_recording_mod": 8, "ghs_get_sweep_length": 8, "ghs_set_sweep_length": 8, "ghs_get_continuous_recording_mod": 8, "ghs_set_continuous_recording_mod": 8, "ghs_get_continuous_lead_out_tim": 8, "ghs_set_continuous_lead_out_tim": 8, "ghs__get_aplifier_mod": 8, "ghs_set_aplifier_mod": 8, "alik": [8, 14], "stream": [8, 14], "ghs_initiate_field_bus_data_transf": 8, "ghs_stop_field_bus_data_transf": 8, "ghs_receive_field_bus_data": 8, "identity_flag": 9, "bool": 9, "identif": 9, "sound": 9, "identifi": 9, "total": 9, "intern": [9, 14], "disk": [9, 14], "space": 9, "gb": 9, "sync": 9, "ghssyncstatu": 9, "slot_count": 9, "ghsusermod": 9, "user_mod": 9, "serial": [9, 12], "firmwar": [9, 12], "mainframetyp": 9, "mainframenam": 9, "serialnumb": [9, 12], "firmwarevers": [9, 12], "mainframe_typ": 9, "mainframe_nam": 9, "serial_numb": [9, 12], "firmware_vers": [9, 12], "byte": 10, "blob": 10, "As": 10, "variabl": 10, "size": 10, "upon": 10, "caller": 10, "ensur": 10, "amount": 10, "memori": 10, "pointer": 10, "blob_siz": 10, "persist": 10, "appli": 10, "boot": 10, "being": 10, "re": 10, "map": 10, "featur": [10, 13], "ghsstorageloc": 11, "storage_loc": 11, "recording_base_nam": 11, "recording_index": 11, "recording_nam": 11, "recent": 11, "asynchron": 11, "high": [11, 12], "low": [11, 12], "indic": 11, "store": 11, "high_rate_en": 11, "low_rate_en": 11, "remot": [11, 14], "local1": 11, "local2": 11, "iscsi1": 11, "iscsi2": 11, "mention": 11, "syncchannel": 11, "syncrealtimeformula": 11, "recordertyp": 12, "recordernam": 12, "recorder_typ": 12, "recorder_nam": 12, "ghs_enabl": 12, "ghs_disabl": 12, "channel_count": 12, "sample_r": 12, "per": 12, "digital_output": 12, "digit": 12, "output": 12, "ghsdigitaloutmod": 12, "digital_output_mod": 12, "output1": 12, "output2": 12, "alarm": 12, "It": 14, "move": 14, "copi": 14, "pc": 14, "via": 14, "want": 14, "do": 14, "done": 14, "dialog": 14, "find": 14, "how": 14, "look": 14, "item": 14, "gen3i": 14, "gen3t": 14, "gen7i": 14, "gen7ta": 14, "gen2tb": 14, "t": 14, "made": 14, "don": 14, "doe": 14, "integr": 14}, "objects": {"ghsapi.ghsapi.GHS": [[10, 0, 1, "", "ghs_apply_persisted_settings"], [2, 0, 1, "", "ghs_cmd_auto_range_now"], [1, 0, 1, "", "ghs_cmd_zeroing"], [4, 0, 1, "", "ghs_connect"], [11, 0, 1, "", "ghs_delete_all_recordings"], [11, 0, 1, "", "ghs_delete_last_recording"], [4, 0, 1, "", "ghs_disconnect"], [0, 0, 1, "", "ghs_get_acquisition_start_time"], [0, 0, 1, "", "ghs_get_acquisition_state"], [0, 0, 1, "", "ghs_get_acquisition_time"], [2, 0, 1, "", "ghs_get_amplifier_mode"], [2, 0, 1, "", "ghs_get_auto_range"], [2, 0, 1, "", "ghs_get_channel_cal_info"], [12, 0, 1, "", "ghs_get_channel_count"], [1, 0, 1, "", "ghs_get_channel_name"], [1, 0, 1, "", "ghs_get_channel_storage_enabled"], [1, 0, 1, "", "ghs_get_channel_type"], [4, 0, 1, "", "ghs_get_client_api_version"], [4, 0, 1, "", "ghs_get_current_access"], [10, 0, 1, "", "ghs_get_current_settings"], [12, 0, 1, "", "ghs_get_digital_output"], [9, 0, 1, "", "ghs_get_disk_space"], [2, 0, 1, "", "ghs_get_excitation"], [5, 0, 1, "", "ghs_get_fieldbus_data_count"], [5, 0, 1, "", "ghs_get_fieldbus_data_name_and_unit"], [2, 0, 1, "", "ghs_get_filter_type_and_frequency"], [11, 0, 1, "", "ghs_get_high_low_rate_storage_enabled"], [2, 0, 1, "", "ghs_get_input_coupling"], [9, 0, 1, "", "ghs_get_mainframe_info"], [12, 0, 1, "", "ghs_get_recorder_enabled"], [12, 0, 1, "", "ghs_get_recorder_info"], [11, 0, 1, "", "ghs_get_recording_name"], [12, 0, 1, "", "ghs_get_sample_rate"], [2, 0, 1, "", "ghs_get_signal_coupling"], [9, 0, 1, "", "ghs_get_slot_count"], [2, 0, 1, "", "ghs_get_span_and_offset"], [11, 0, 1, "", "ghs_get_storage_location"], [9, 0, 1, "", "ghs_get_sync_status"], [2, 0, 1, "", "ghs_get_technical_units"], [3, 0, 1, "", "ghs_get_timer_counter_gate_time"], [3, 0, 1, "", "ghs_get_timer_counter_mode"], [3, 0, 1, "", "ghs_get_timer_counter_range"], [2, 0, 1, "", "ghs_get_trigger_settings"], [9, 0, 1, "", "ghs_get_user_mode"], [9, 0, 1, "", "ghs_identify"], [5, 0, 1, "", "ghs_initiate_fieldbus_data_transfer"], [0, 0, 1, "", "ghs_pause_recording"], [10, 0, 1, "", "ghs_persist_current_settings"], [5, 0, 1, "", "ghs_read_next_snapshot"], [5, 0, 1, "", "ghs_receive_fieldbus_data"], [5, 0, 1, "", "ghs_request_fieldbus_snapshot"], [0, 0, 1, "", "ghs_resume_recording"], [2, 0, 1, "", "ghs_set_amplifier_mode"], [2, 0, 1, "", "ghs_set_auto_range"], [1, 0, 1, "", "ghs_set_channel_name"], [1, 0, 1, "", "ghs_set_channel_storage_enabled"], [10, 0, 1, "", "ghs_set_current_settings"], [12, 0, 1, "", "ghs_set_digital_output"], [2, 0, 1, "", "ghs_set_excitation"], [2, 0, 1, "", "ghs_set_filter_type_and_frequency"], [11, 0, 1, "", "ghs_set_high_low_rate_storage_enabled"], [2, 0, 1, "", "ghs_set_input_coupling"], [12, 0, 1, "", "ghs_set_recorder_enabled"], [11, 0, 1, "", "ghs_set_recording_name"], [12, 0, 1, "", "ghs_set_sample_rate"], [2, 0, 1, "", "ghs_set_signal_coupling"], [2, 0, 1, "", "ghs_set_span_and_offset"], [11, 0, 1, "", "ghs_set_storage_location"], [2, 0, 1, "", "ghs_set_technical_units"], [3, 0, 1, "", "ghs_set_timer_counter_gate_time"], [3, 0, 1, "", "ghs_set_timer_counter_mode"], [3, 0, 1, "", "ghs_set_timer_counter_range"], [2, 0, 1, "", "ghs_set_trigger_settings"], [9, 0, 1, "", "ghs_set_user_mode"], [0, 0, 1, "", "ghs_start_preview"], [0, 0, 1, "", "ghs_start_recording"], [5, 0, 1, "", "ghs_stop_fieldbus_data_transfer"], [0, 0, 1, "", "ghs_stop_preview"], [0, 0, 1, "", "ghs_stop_recording"], [0, 0, 1, "", "ghs_trigger"]]}, "objtypes": {"0": "py:method"}, "objnames": {"0": ["py", "method", "Python method"]}, "titleterms": {"acquisit": 0, "control": 0, "channel": 1, "modul": 1, "function": [1, 6], "analog": 2, "timer": 3, "counter": 3, "connect": 4, "fieldbu": 5, "api": [6, 7], "gen": 7, "daq": 7, "python": 7, "driver": 7, "": 7, "document": 7, "content": 7, "introduct": 8, "mainfram": [9, 10], "manag": [10, 11], "set": 10, "record": [11, 12], "releas": 13, "note": 13, "version": 13, "1": 13, "0": 13, "remark": 14}, "envversion": {"sphinx.domains.c": 2, "sphinx.domains.changeset": 1, "sphinx.domains.citation": 1, "sphinx.domains.cpp": 8, "sphinx.domains.index": 1, "sphinx.domains.javascript": 2, "sphinx.domains.math": 2, "sphinx.domains.python": 3, "sphinx.domains.rst": 2, "sphinx.domains.std": 2, "sphinx.ext.viewcode": 1, "sphinx": 57}, "alltitles": {"API Functions": [[6, "api-functions"]], "GEN DAQ API - Python Driver\u2019s documentation": [[7, "gen-daq-api-python-driver-s-documentation"]], "Contents": [[7, "contents"]], "Introduction": [[8, "introduction"]], "Release Notes": [[13, "release-notes"]], "Version 1.0": [[13, "version-1-0"]], "Version 1.1": [[13, "version-1-1"]], "Remarks": [[14, "remarks"]], "Acquisition control": [[0, "acquisition-control"]], "Channel": [[1, "channel"]], "Modules": [[1, "modules"]], "Functions": [[1, "functions"]], "Analog": [[2, "analog"]], "Timer/Counter": [[3, "timer-counter"]], "Connections": [[4, "connections"]], "FieldBus": [[5, "fieldbus"]], "Mainframe": [[9, "mainframe"]], "Manage mainframe settings": [[10, "manage-mainframe-settings"]], "Manage recordings": [[11, "manage-recordings"]], "Recorder": [[12, "recorder"]]}, "indexentries": {"ghs_get_acquisition_start_time() (ghsapi.ghsapi.ghs method)": [[0, "ghsapi.ghsapi.GHS.ghs_get_acquisition_start_time"]], "ghs_get_acquisition_state() (ghsapi.ghsapi.ghs method)": [[0, "ghsapi.ghsapi.GHS.ghs_get_acquisition_state"]], "ghs_get_acquisition_time() (ghsapi.ghsapi.ghs method)": [[0, "ghsapi.ghsapi.GHS.ghs_get_acquisition_time"]], "ghs_pause_recording() (ghsapi.ghsapi.ghs method)": [[0, "ghsapi.ghsapi.GHS.ghs_pause_recording"]], "ghs_resume_recording() (ghsapi.ghsapi.ghs method)": [[0, "ghsapi.ghsapi.GHS.ghs_resume_recording"]], "ghs_start_preview() (ghsapi.ghsapi.ghs method)": [[0, "ghsapi.ghsapi.GHS.ghs_start_preview"]], "ghs_start_recording() (ghsapi.ghsapi.ghs method)": [[0, "ghsapi.ghsapi.GHS.ghs_start_recording"]], "ghs_stop_preview() (ghsapi.ghsapi.ghs method)": [[0, "ghsapi.ghsapi.GHS.ghs_stop_preview"]], "ghs_stop_recording() (ghsapi.ghsapi.ghs method)": [[0, "ghsapi.ghsapi.GHS.ghs_stop_recording"]], "ghs_trigger() (ghsapi.ghsapi.ghs method)": [[0, "ghsapi.ghsapi.GHS.ghs_trigger"]], "ghs_cmd_zeroing() (ghsapi.ghsapi.ghs method)": [[1, "ghsapi.ghsapi.GHS.ghs_cmd_zeroing"]], "ghs_get_channel_name() (ghsapi.ghsapi.ghs method)": [[1, "ghsapi.ghsapi.GHS.ghs_get_channel_name"]], "ghs_get_channel_storage_enabled() (ghsapi.ghsapi.ghs method)": [[1, "ghsapi.ghsapi.GHS.ghs_get_channel_storage_enabled"]], "ghs_get_channel_type() (ghsapi.ghsapi.ghs method)": [[1, "ghsapi.ghsapi.GHS.ghs_get_channel_type"]], "ghs_set_channel_name() (ghsapi.ghsapi.ghs method)": [[1, "ghsapi.ghsapi.GHS.ghs_set_channel_name"]], "ghs_set_channel_storage_enabled() (ghsapi.ghsapi.ghs method)": [[1, "ghsapi.ghsapi.GHS.ghs_set_channel_storage_enabled"]], "ghs_cmd_auto_range_now() (ghsapi.ghsapi.ghs method)": [[2, "ghsapi.ghsapi.GHS.ghs_cmd_auto_range_now"]], "ghs_get_amplifier_mode() (ghsapi.ghsapi.ghs method)": [[2, "ghsapi.ghsapi.GHS.ghs_get_amplifier_mode"]], "ghs_get_auto_range() (ghsapi.ghsapi.ghs method)": [[2, "ghsapi.ghsapi.GHS.ghs_get_auto_range"]], "ghs_get_channel_cal_info() (ghsapi.ghsapi.ghs method)": [[2, "ghsapi.ghsapi.GHS.ghs_get_channel_cal_info"]], "ghs_get_excitation() (ghsapi.ghsapi.ghs method)": [[2, "ghsapi.ghsapi.GHS.ghs_get_excitation"]], "ghs_get_filter_type_and_frequency() (ghsapi.ghsapi.ghs method)": [[2, "ghsapi.ghsapi.GHS.ghs_get_filter_type_and_frequency"]], "ghs_get_input_coupling() (ghsapi.ghsapi.ghs method)": [[2, "ghsapi.ghsapi.GHS.ghs_get_input_coupling"]], "ghs_get_signal_coupling() (ghsapi.ghsapi.ghs method)": [[2, "ghsapi.ghsapi.GHS.ghs_get_signal_coupling"]], "ghs_get_span_and_offset() (ghsapi.ghsapi.ghs method)": [[2, "ghsapi.ghsapi.GHS.ghs_get_span_and_offset"]], "ghs_get_technical_units() (ghsapi.ghsapi.ghs method)": [[2, "ghsapi.ghsapi.GHS.ghs_get_technical_units"]], "ghs_get_trigger_settings() (ghsapi.ghsapi.ghs method)": [[2, "ghsapi.ghsapi.GHS.ghs_get_trigger_settings"]], "ghs_set_amplifier_mode() (ghsapi.ghsapi.ghs method)": [[2, "ghsapi.ghsapi.GHS.ghs_set_amplifier_mode"]], "ghs_set_auto_range() (ghsapi.ghsapi.ghs method)": [[2, "ghsapi.ghsapi.GHS.ghs_set_auto_range"]], "ghs_set_excitation() (ghsapi.ghsapi.ghs method)": [[2, "ghsapi.ghsapi.GHS.ghs_set_excitation"]], "ghs_set_filter_type_and_frequency() (ghsapi.ghsapi.ghs method)": [[2, "ghsapi.ghsapi.GHS.ghs_set_filter_type_and_frequency"]], "ghs_set_input_coupling() (ghsapi.ghsapi.ghs method)": [[2, "ghsapi.ghsapi.GHS.ghs_set_input_coupling"]], "ghs_set_signal_coupling() (ghsapi.ghsapi.ghs method)": [[2, "ghsapi.ghsapi.GHS.ghs_set_signal_coupling"]], "ghs_set_span_and_offset() (ghsapi.ghsapi.ghs method)": [[2, "ghsapi.ghsapi.GHS.ghs_set_span_and_offset"]], "ghs_set_technical_units() (ghsapi.ghsapi.ghs method)": [[2, "ghsapi.ghsapi.GHS.ghs_set_technical_units"]], "ghs_set_trigger_settings() (ghsapi.ghsapi.ghs method)": [[2, "ghsapi.ghsapi.GHS.ghs_set_trigger_settings"]], "ghs_get_timer_counter_gate_time() (ghsapi.ghsapi.ghs method)": [[3, "ghsapi.ghsapi.GHS.ghs_get_timer_counter_gate_time"]], "ghs_get_timer_counter_mode() (ghsapi.ghsapi.ghs method)": [[3, "ghsapi.ghsapi.GHS.ghs_get_timer_counter_mode"]], "ghs_get_timer_counter_range() (ghsapi.ghsapi.ghs method)": [[3, "ghsapi.ghsapi.GHS.ghs_get_timer_counter_range"]], "ghs_set_timer_counter_gate_time() (ghsapi.ghsapi.ghs method)": [[3, "ghsapi.ghsapi.GHS.ghs_set_timer_counter_gate_time"]], "ghs_set_timer_counter_mode() (ghsapi.ghsapi.ghs method)": [[3, "ghsapi.ghsapi.GHS.ghs_set_timer_counter_mode"]], "ghs_set_timer_counter_range() (ghsapi.ghsapi.ghs method)": [[3, "ghsapi.ghsapi.GHS.ghs_set_timer_counter_range"]], "ghs_connect() (ghsapi.ghsapi.ghs method)": [[4, "ghsapi.ghsapi.GHS.ghs_connect"]], "ghs_disconnect() (ghsapi.ghsapi.ghs method)": [[4, "ghsapi.ghsapi.GHS.ghs_disconnect"]], "ghs_get_client_api_version() (ghsapi.ghsapi.ghs method)": [[4, "ghsapi.ghsapi.GHS.ghs_get_client_api_version"]], "ghs_get_current_access() (ghsapi.ghsapi.ghs method)": [[4, "ghsapi.ghsapi.GHS.ghs_get_current_access"]], "ghs_get_fieldbus_data_count() (ghsapi.ghsapi.ghs method)": [[5, "ghsapi.ghsapi.GHS.ghs_get_fieldbus_data_count"]], "ghs_get_fieldbus_data_name_and_unit() (ghsapi.ghsapi.ghs method)": [[5, "ghsapi.ghsapi.GHS.ghs_get_fieldbus_data_name_and_unit"]], "ghs_initiate_fieldbus_data_transfer() (ghsapi.ghsapi.ghs method)": [[5, "ghsapi.ghsapi.GHS.ghs_initiate_fieldbus_data_transfer"]], "ghs_read_next_snapshot() (ghsapi.ghsapi.ghs method)": [[5, "ghsapi.ghsapi.GHS.ghs_read_next_snapshot"]], "ghs_receive_fieldbus_data() (ghsapi.ghsapi.ghs method)": [[5, "ghsapi.ghsapi.GHS.ghs_receive_fieldbus_data"]], "ghs_request_fieldbus_snapshot() (ghsapi.ghsapi.ghs method)": [[5, "ghsapi.ghsapi.GHS.ghs_request_fieldbus_snapshot"]], "ghs_stop_fieldbus_data_transfer() (ghsapi.ghsapi.ghs method)": [[5, "ghsapi.ghsapi.GHS.ghs_stop_fieldbus_data_transfer"]], "ghs_get_disk_space() (ghsapi.ghsapi.ghs method)": [[9, "ghsapi.ghsapi.GHS.ghs_get_disk_space"]], "ghs_get_mainframe_info() (ghsapi.ghsapi.ghs method)": [[9, "ghsapi.ghsapi.GHS.ghs_get_mainframe_info"]], "ghs_get_slot_count() (ghsapi.ghsapi.ghs method)": [[9, "ghsapi.ghsapi.GHS.ghs_get_slot_count"]], "ghs_get_sync_status() (ghsapi.ghsapi.ghs method)": [[9, "ghsapi.ghsapi.GHS.ghs_get_sync_status"]], "ghs_get_user_mode() (ghsapi.ghsapi.ghs method)": [[9, "ghsapi.ghsapi.GHS.ghs_get_user_mode"]], "ghs_identify() (ghsapi.ghsapi.ghs method)": [[9, "ghsapi.ghsapi.GHS.ghs_identify"]], "ghs_set_user_mode() (ghsapi.ghsapi.ghs method)": [[9, "ghsapi.ghsapi.GHS.ghs_set_user_mode"]], "ghs_apply_persisted_settings() (ghsapi.ghsapi.ghs method)": [[10, "ghsapi.ghsapi.GHS.ghs_apply_persisted_settings"]], "ghs_get_current_settings() (ghsapi.ghsapi.ghs method)": [[10, "ghsapi.ghsapi.GHS.ghs_get_current_settings"]], "ghs_persist_current_settings() (ghsapi.ghsapi.ghs method)": [[10, "ghsapi.ghsapi.GHS.ghs_persist_current_settings"]], "ghs_set_current_settings() (ghsapi.ghsapi.ghs method)": [[10, "ghsapi.ghsapi.GHS.ghs_set_current_settings"]], "ghs_delete_all_recordings() (ghsapi.ghsapi.ghs method)": [[11, "ghsapi.ghsapi.GHS.ghs_delete_all_recordings"]], "ghs_delete_last_recording() (ghsapi.ghsapi.ghs method)": [[11, "ghsapi.ghsapi.GHS.ghs_delete_last_recording"]], "ghs_get_high_low_rate_storage_enabled() (ghsapi.ghsapi.ghs method)": [[11, "ghsapi.ghsapi.GHS.ghs_get_high_low_rate_storage_enabled"]], "ghs_get_recording_name() (ghsapi.ghsapi.ghs method)": [[11, "ghsapi.ghsapi.GHS.ghs_get_recording_name"]], "ghs_get_storage_location() (ghsapi.ghsapi.ghs method)": [[11, "ghsapi.ghsapi.GHS.ghs_get_storage_location"]], "ghs_set_high_low_rate_storage_enabled() (ghsapi.ghsapi.ghs method)": [[11, "ghsapi.ghsapi.GHS.ghs_set_high_low_rate_storage_enabled"]], "ghs_set_recording_name() (ghsapi.ghsapi.ghs method)": [[11, "ghsapi.ghsapi.GHS.ghs_set_recording_name"]], "ghs_set_storage_location() (ghsapi.ghsapi.ghs method)": [[11, "ghsapi.ghsapi.GHS.ghs_set_storage_location"]], "ghs_get_channel_count() (ghsapi.ghsapi.ghs method)": [[12, "ghsapi.ghsapi.GHS.ghs_get_channel_count"]], "ghs_get_digital_output() (ghsapi.ghsapi.ghs method)": [[12, "ghsapi.ghsapi.GHS.ghs_get_digital_output"]], "ghs_get_recorder_enabled() (ghsapi.ghsapi.ghs method)": [[12, "ghsapi.ghsapi.GHS.ghs_get_recorder_enabled"]], "ghs_get_recorder_info() (ghsapi.ghsapi.ghs method)": [[12, "ghsapi.ghsapi.GHS.ghs_get_recorder_info"]], "ghs_get_sample_rate() (ghsapi.ghsapi.ghs method)": [[12, "ghsapi.ghsapi.GHS.ghs_get_sample_rate"]], "ghs_set_digital_output() (ghsapi.ghsapi.ghs method)": [[12, "ghsapi.ghsapi.GHS.ghs_set_digital_output"]], "ghs_set_recorder_enabled() (ghsapi.ghsapi.ghs method)": [[12, "ghsapi.ghsapi.GHS.ghs_set_recorder_enabled"]], "ghs_set_sample_rate() (ghsapi.ghsapi.ghs method)": [[12, "ghsapi.ghsapi.GHS.ghs_set_sample_rate"]]}})
\ No newline at end of file
diff --git a/examples/example_fieldbus.py b/examples/example_fieldbus.py
index 66a3df9..fec74b6 100644
--- a/examples/example_fieldbus.py
+++ b/examples/example_fieldbus.py
@@ -57,22 +57,12 @@ def main():
         sys.exit()
     print(f"GHSConnect - Return Status: {return_var}")
 
-    # Open a new connection for the field bus data
-    (
-        return_var,
-        update_rate,
-        data_count,
-    ) = gen.ghs_initiate_fieldbus_data_transfer(update_rate)
+    # Stop preview mode
+    return_var = gen.ghs_stop_preview()
     if return_var != "OK":
-        print(
-            f"Failed on GHSInitiateFieldBusDataTransfer. Return Status: {return_var}"
-        )
-        sys.exit()
-    print(
-        f"GHSInitiateFieldBusDataTransfer - Return Status: {return_var}\
-        \nUpdate rate : {update_rate}\
-        Data count: {data_count}"
-    )
+        print(f"Failed on GHSStopPreview. Return Status: {return_var}")
+        # sys.exit()
+    print(f"GHSStopPreview - Return Status: {return_var}")
 
     # Closes the socket dedicated for the field bus data and stops transfering data.
     return_var = gen.ghs_stop_fieldbus_data_transfer()
@@ -80,7 +70,7 @@ def main():
         print(
             f"Failed on GHSStopFieldBusDataTransfer. Return Status: {return_var}"
         )
-        sys.exit()
+        # sys.exit()
     print(f"GHSStopFieldBusDataTransfer - Return Status: {return_var}")
 
     # Gets the number of data that are configured to be sent through the field bus
@@ -105,9 +95,9 @@ def main():
         ) = gen.ghs_get_fieldbus_data_name_and_unit(data_index)
         if return_var != "OK":
             print(
-                f"Failed on GHSGetFieldBusDataNameAndUnit for index {data_index + 1}. Return Status: {return_var}"
+                f"Failed on GHSGetFieldBusDataNameAndUnit for index {data_index}. Return Status: {return_var}"
             )
-            sys.exit()
+            # sys.exit()
         print(
             f"GHSGetFieldBusDataNameAndUnit - Return Status: {return_var}\
             \nData index : {data_index}\
@@ -129,7 +119,7 @@ def main():
         time_stamp,
         data_count,
         data,
-    ) = gen.ghs_request_fieldbus_snapshot()
+    ) = gen.ghs_request_fieldbus_snapshot(data_count)
     if return_var != "OK":
         print(
             f"Failed on GHSRequestFieldBusSnapshot. Return Status: {return_var}"
@@ -142,6 +132,61 @@ def main():
         Data: {data}"
     )
 
+    # Open a new connection for the field bus data
+    (
+        return_var,
+        update_rate,
+        data_count,
+    ) = gen.ghs_initiate_fieldbus_data_transfer(update_rate)
+    if return_var != "OK":
+        print(
+            f"Failed on GHSInitiateFieldBusDataTransfer. Return Status: {return_var}"
+        )
+        sys.exit()
+    print(
+        f"GHSInitiateFieldBusDataTransfer - Return Status: {return_var}\
+        \nUpdate rate : {update_rate}\
+        Data count: {data_count}"
+    )
+
+    # Used to retrieve the FieldBus data from the new socket connection and write on the buffer
+    count = 0
+    number_reads = 5
+    while count < number_reads:
+        return_var = gen.ghs_receive_fieldbus_data()
+        if return_var != "OK":
+            print(
+                f"Failed on GHSReceiveFieldBusData. Return Status: {return_var}"
+            )
+            sys.exit()
+        print(f"GHSReceiveFieldBusData - Return Status: {return_var}")
+
+        # Retrieves the next snapshot in the buffer.
+        (
+            return_var,
+            time_stamp,
+            values,
+            overrun,
+        ) = gen.ghs_read_next_snapshot("BlockingCall")
+        if return_var != "OK":
+            print(
+                f"Failed on GHSReadNextSnapshot. Return Status: {return_var}"
+            )
+            sys.exit()
+        print(
+            f"GHSReadNextSnapshot - Return Status: {return_var} \t Timestamp: {time_stamp} \t Values: {values} \t Overrun: {overrun}"
+        )
+        count += 1
+
+    # Closes the socket dedicated for the field bus data and stops transfering data.
+    return_var = gen.ghs_stop_fieldbus_data_transfer()
+    if return_var != "OK":
+        print(
+            f"Failed on GHSStopFieldBusDataTransfer. Return Status: {return_var}"
+        )
+        sys.exit()
+    print(f"GHSStopFieldBusDataTransfer - Return Status: {return_var}")
+
     # Stop preview mode
     return_var = gen.ghs_stop_preview()
     if return_var != "OK":
diff --git a/examples/example_ringbuffer.py b/examples/example_ringbuffer.py
index b0cf442..129afe5 100644
--- a/examples/example_ringbuffer.py
+++ b/examples/example_ringbuffer.py
@@ -34,13 +34,13 @@
 
 sys.path.append(parentdir)
 
-from src.ghsapi import fieldbus_ring_buffer
+from src.ghsapi import fieldbus_ringbuffer
 
 
 def main():
     """Code example to use ring buffer class"""
 
-    ring_buffer = fieldbus_ring_buffer.FieldBusRingBuffer(5, 2)
+    ring_buffer = fieldbus_ringbuffer.FieldBusRingBuffer(5, 2)
     print(f"Ring buffer current size {ring_buffer.ring_buffer_size()}")
     print(
         f"Is ring buffer empty? {'no' if ring_buffer.ring_buffer_size() else 'yes'}"
diff --git a/source/fieldbus.rst b/source/fieldbus.rst
new file mode 100644
index 0000000..617273e
--- /dev/null
+++ b/source/fieldbus.rst
@@ -0,0 +1,12 @@
+FieldBus
+===========
+
+FieldBus related API functions.
+
+.. automethod:: ghsapi.ghsapi.GHS.ghs_get_fieldbus_data_count
+.. automethod:: ghsapi.ghsapi.GHS.ghs_get_fieldbus_data_name_and_unit
+.. automethod:: ghsapi.ghsapi.GHS.ghs_initiate_fieldbus_data_transfer
+.. automethod:: ghsapi.ghsapi.GHS.ghs_stop_fieldbus_data_transfer
+.. automethod:: ghsapi.ghsapi.GHS.ghs_receive_fieldbus_data
+.. automethod:: ghsapi.ghsapi.GHS.ghs_read_next_snapshot
+.. automethod:: ghsapi.ghsapi.GHS.ghs_request_fieldbus_snapshot
\ No newline at end of file
diff --git a/source/ghspyapi.rst b/source/ghspyapi.rst
index fcb9195..c242261 100644
--- a/source/ghspyapi.rst
+++ b/source/ghspyapi.rst
@@ -13,3 +13,4 @@ All available API functions:
    managemainframe
    recorder
    channel
+   fieldbus
\ No newline at end of file
diff --git a/src/ghsapi/connection.py b/src/ghsapi/connection.py
index 6e87c3f..bd3280f 100644
--- a/src/ghsapi/connection.py
+++ b/src/ghsapi/connection.py
@@ -31,9 +31,6 @@
 from . import json_rpc
 from .ghsapi_states import RETURN_KEY, GHSReturnValue
 
-MAX_CONNECTIONS = 30
-
-
 class ConnectionHandler:
     """A unique identifier per mainframe connection.
 
@@ -47,6 +44,8 @@ class ConnectionHandler:
         ip_address: Mainframe ip address
     """
 
+    MAX_CONNECTIONS = 30
+
     connection_count = 0
     api_version_header = 1195638785
 
@@ -78,7 +77,7 @@ def connection_establish(self, ip_address: int, port_num: int) -> int:
 
         if not ip_address or not port_num:
             return GHSReturnValue["NullPtrArgument"]
-        if self.get_num_of_connections() > MAX_CONNECTIONS:
+        if self.get_num_of_connections() > self.MAX_CONNECTIONS:
             return GHSReturnValue["ConnectionFailed"]
 
         try:
@@ -214,4 +213,4 @@ def connection_write(self, message: bytes, length: int) -> int:
             written_bytes = written_bytes + sent_bytes
             sent_bytes = 0
 
-        return written_bytes
+        return written_bytes
\ No newline at end of file
diff --git a/src/ghsapi/fieldbus_api.py b/src/ghsapi/fieldbus_api.py
index 1eeb8e2..3631a24 100644
--- a/src/ghsapi/fieldbus_api.py
+++ b/src/ghsapi/fieldbus_api.py
@@ -24,23 +24,38 @@
 
 """FieldBus module interface."""
 
-from .connection import ConnectionHandler
-from .ghsapi_states import RETURN_KEY, GHSReturnValue, to_string
+import sys
+import struct
 
+from .connection import ConnectionHandler
+from .fieldbus_ringbuffer import FieldBusData
+from .fieldbus_ringbuffer import FieldBus
+from .ghsapi_states import (
+    RETURN_KEY,
+    GHSReturnValue,
+    GHSFunctionCallType,
+    to_string,
+    from_string
+)
+
+SIZE_OF_FLOAT = 4
+SIZE_OF_DOUBLE = 8
 
 def initiate_fieldbus_data_transfer(
-    con_handle: ConnectionHandler, update_rate: int
+    con_handle: ConnectionHandler, update_rate: int, fieldbus_handle: FieldBus
 ) -> tuple[str, int | None, int | None]:
     """Opens a new connection for the field bus data, and waits for client to
     connect. Once the client connects, if the acquisition state is active,
     data is sent to the client. Otherwise nothing is sent.
 
-    If no formulas are present then you get error code back:
-    GHSReturnValue_FieldBusError_NotConfigured if the field bus is already
-    initiated then an error code is returned:
-    GHSReturnValue_FieldBusError_FieldBusEnabled. To change the update rate
-    the field bus needs to be stoped and inititate again with a new update
-    rate.
+    * If no formulas are present then you get error code back:
+    GHSReturnValue_FieldBusError_NotConfigured
+
+    * If the field bus is already initiated then an error code is returned:
+    GHSReturnValue_FieldBusError_FieldBusEnabled.
+
+    *To change the update rate the field bus needs
+    to be stoped and inititate again with a new update rate.
 
     Args:
         con_handle: The unique connection identifier returned by GHSConnect
@@ -82,6 +97,19 @@ def initiate_fieldbus_data_transfer(
             None,
         )
 
+    bufferDepth = response_json["BufferDepth"]
+    dataCount = response_json["DataCount"]
+    fieldBusPort = response_json["FieldBusPort"]
+    fieldbus_handle.__init__(bufferDepth, dataCount)
+    if not fieldbus_handle.dataHandle:
+        return "FieldBusError_NullFieldBusRingBuffer", None, None
+
+    ConnectionHandler.connection_establish (
+        fieldbus_handle.conHandle,
+        fieldbus_handle.ipAddress,
+        fieldBusPort
+    )
+
     return (
         to_string(response_json[RETURN_KEY], GHSReturnValue),
         response_json["UpdateRate"],
@@ -94,7 +122,7 @@ def stop_fieldbus_data_transfer(con_handle: ConnectionHandler) -> str:
     transfering data. The ring buffer allocated for the transfer data is
     deleted.
 
-    Field bus data transfer must have been initiated before calling this
+    * Fieldbus data transfer must have been initiated before calling this
     function.
 
     Args:
@@ -114,17 +142,18 @@ def stop_fieldbus_data_transfer(con_handle: ConnectionHandler) -> str:
 def get_fieldbus_data_count(
     con_handle: ConnectionHandler,
 ) -> tuple[str, int | None]:
-    """Gets the number of data that are configured to be sent through the
-    field bus, excluding the timestamp.
+    """Gets the number of data that are configured to be sent through the field bus, excluding the timestamp.
+
+    *The number of data values can be retrieved by ghs_get_fieldbus_data_count().
 
-    This method can be called by multiple connected clients at same
-    time.
+    *Read - This method can be called by multiple connected clients at same
+    time.*
 
     Args:
-        con_handle: The unique connection identifier returned by GHSConnect
+        con_handle: A unique identifier per mainframe connection.
 
     Returns:
-       Tuple with status and number of data that are selected to be published.
+       Tuple with status and total number of fieldbus data channel being published.
     """
 
     response_json = con_handle.send_request_wait_response(
@@ -145,24 +174,25 @@ def get_fieldbus_data_count(
 def get_fieldbus_data_name_and_unit(
     con_handle: ConnectionHandler, data_index: int
 ) -> tuple[str, str | None, str | None]:
-    """Gets the name of specific field bus data value, by giving the index of
-    the data value. The number of data values can be retrieved by
-    GHSGetFieldBusDataCount. In case of no formulas (or reserved values
-    acquisition state and latency) published, an error code is returned:
-    GHSReturnValue_FieldBusError_NoFormulasDeployed.
+    """Gets the name of specific field bus data value, by giving the index of the data value.
 
-    This method can be called by multiple connected clients at same
-    time.
+    *The number of data values can be retrieved by ghs_get_fieldbus_data_count().
+
+    *In case of no formulas (or reserved values acquisition state and latency) published,
+    an error code is returned: FieldBusError_NoFormulasDeployed.
+
+    *Read - This method can be called by multiple connected clients at same
+    time.*
 
     Args:
         con_handle: A unique identifier per mainframe connection.
         data_index: Zero-based index of the data value.
 
     Returns:
-       Tuple with status, name and unit of the data value.
+       Tuple with status, data name and data unit for the desired fieldbus index.
     """
 
-    if not data_index and data_index != 0:
+    if data_index < 0:
         return "NullPtrArgument", None, None
 
     data_info_dict = {
@@ -197,25 +227,35 @@ def get_fieldbus_data_name_and_unit(
 
 def request_fieldbus_snapshot(
     con_handle: ConnectionHandler,
+    dataCount: int
 ) -> tuple[str, float | None, int | None, list[float] | None]:
-    """Request a single snapshot of the field bus data. In this case the
-    timestamp received is not grid aligned. If the system is not acquiring the
-    method returns an error code:GHSReturnValue_SystemNotRecording In case of
-    no formulas you get the error return code back:
-    GHSReturnValue_FieldBusError_NotConfigured if the field bus is already
-    enabled then this method is not allowed.An error return code is
-    returned:FieldBusError_UnavailableFunctionality.
+    """ Request a single snapshot of the field bus data.
+
+    *In this case the timestamp received is not grid aligned.
+
+    *If the system is not acquiring the method returns an error code: SystemNotRecording
 
-    This method can be called by multiple connected clients at same
-    time.
+    *In case of no formulas you get the error return code back: FieldBusError_NotConfigured
+
+    *If the fieldbus is already enabled then this method is not allowed.
+    An error return code is returned: FieldBusError_FieldBusAlready_Enabled
+
+    *Read - This method can be called by multiple connected clients at same
+    time.*
 
     Args:
         con_handle: A unique identifier per mainframe connection.
+        data_index: Zero-based index of the data value.
 
     Returns:
-       Tuple with status, timestamp, data count and data.
+       Tuple with status, timestamp, total number of fieldbus channels and the fieldbus data.
     """
 
+    if not dataCount:
+        return "NullPtrArgument", None, None, None
+
+    nClientAllocatedDataSize = dataCount
+
     response_json = con_handle.send_request_wait_response(
         "RequestSnapshot", None
     )
@@ -237,9 +277,137 @@ def request_fieldbus_snapshot(
             None,
         )
 
+    dataCount = response_json["DataCount"]
+    if nClientAllocatedDataSize < dataCount:
+        return "FieldBusError_BufferSizeInvalid"
+
     return (
         to_string(response_json[RETURN_KEY], GHSReturnValue),
         response_json["TimeStamp"],
         response_json["DataCount"],
         response_json["Data"],
     )
+
+
+def receive_fieldbus_data(
+    fieldbus_handle: FieldBus
+) -> str:
+    """Used to retrieve the FieldBus data from the new socket connection and write on the buffer.
+
+    *Can be used in a thread and if so, mutual exclusion should be used with GHSStopFieldBusDataTransfer.
+
+    *This function should be used in a loop if continuous delivery of Async Data is desired.
+
+    *Field bus data transfer must have been initiated before calling this function.
+
+    Args:
+        con_handle: A unique identifier per mainframe connection.
+
+    Returns:
+       String value representing request status.
+    """
+
+    if not fieldbus_handle:
+        return GHSReturnValue["NotConnected"]
+
+    packetSize = fieldbus_handle.dataHandle.data_count
+
+    packet = FieldBusData(packetSize)
+
+    fieldBusPacketSize = SIZE_OF_DOUBLE + SIZE_OF_FLOAT * packetSize
+    returnTuple = connection_read_raw(fieldbus_handle, fieldBusPacketSize)
+    returnValue = returnTuple[0]
+    if (returnValue != GHSReturnValue["OK"]):
+        return returnValue
+
+    fieldBusStream = returnTuple[1]
+    packet.timeStamp = struct.unpack('d', fieldBusStream[:SIZE_OF_DOUBLE])[0]
+    byte_index = SIZE_OF_DOUBLE
+    if packet.fValues:
+        while byte_index < fieldBusPacketSize:
+            values_index = int(byte_index / SIZE_OF_FLOAT) - 2
+            data_string = fieldBusStream[byte_index:byte_index + SIZE_OF_FLOAT]
+            packet.fValues[values_index] = struct.unpack('f', fieldBusStream[byte_index:byte_index + SIZE_OF_FLOAT])[0]
+            byte_index += SIZE_OF_FLOAT
+
+    fieldbus_handle.dataHandle.put_data(packet.timeStamp, packet.fValues)
+
+    return to_string(returnValue, GHSReturnValue)
+
+
+def connection_read_raw(fieldbus: FieldBus, size) -> tuple[int | None, bytes | None]:
+    """Establishes connection to the mainframe.
+
+    Args:
+        ip_address: IP address of the mainframe.
+        port_num: Mainframe port number.
+
+    Returns:
+        Integer value representing connection status code.
+    """
+
+    if not fieldbus or not fieldbus.ipAddress:
+        return GHSReturnValue["NullPtrArgument"]
+    if (fieldbus.conHandle.get_num_of_connections() > fieldbus.conHandle.MAX_CONNECTIONS
+        or fieldbus.conHandle.connection_count == 0):
+        return GHSReturnValue["InvalidHandle"]
+    if not fieldbus.conHandle.sock:
+        return GHSReturnValue["NoConnection"]
+
+    msg = fieldbus.conHandle.connection_read(size)
+    msg_size = len(msg)
+    if msg_size != size:
+        return GHSReturnValue["NOK"]
+
+    return [GHSReturnValue["OK"], msg]
+
+
+
+def read_next_snapshot(
+    fieldbus_handle: FieldBus,
+    call_type: str | int
+) -> tuple[str, float | None, float | None, int | None]:
+    """Retrieves the next snapshot in the buffer.
+
+    * The timestamp is grid aligned - as specified by the 'updateRate' argument
+    of the GHSInitiateFieldBusDataTransfer() method.
+
+    Args:
+        con_handle: A unique identifier per mainframe connection.
+
+    Returns:
+       String value representing request status.
+    """
+
+    if not call_type:
+        return "NullPtrArgument", None, None, None
+
+    if not fieldbus_handle.dataHandle:
+        return "FieldBusError_NullFieldBusRingBuffer", None, None, None
+
+    if isinstance(call_type, int) and call_type in GHSFunctionCallType:
+        call_type = to_string(call_type, GHSFunctionCallType)
+    elif (
+        isinstance(call_type, int)
+        and call_type in GHSFunctionCallType.values()
+    ):
+        pass
+
+    if (not fieldbus_handle.dataHandle.ring_buffer_get_size() and call_type == "NonBlockingCall"):
+        timestamp = fieldbus_handle.lastPacket.timeStamp
+        values = fieldbus_handle.lastPacket.fValues
+        overrun = 0
+    else:
+        tuple = fieldbus_handle.dataHandle.get_data()
+        timestamp = tuple[0]
+        values = tuple[1]
+        overrun = tuple[2]
+        if overrun:
+            fieldbus_handle.dataHandle.overrun = 0
+
+    return (
+        "OK",
+        timestamp,
+        values,
+        overrun
+    )
diff --git a/src/ghsapi/fieldbus_ring_buffer.py b/src/ghsapi/fieldbus_ring_buffer.py
deleted file mode 100644
index 853f70c..0000000
--- a/src/ghsapi/fieldbus_ring_buffer.py
+++ /dev/null
@@ -1,83 +0,0 @@
-"""FieldBus Ring Buffer"""
-
-from collections import deque
-
-
-class FieldBusData:
-    """FieldBus incoming packets, includes a timestamp and async values"""
-
-    def __init__(self) -> None:
-        self.time_stamp = None
-        self.values = []
-
-
-class RingBuffer:
-    """FieldBus Ring Buffer"""
-
-    def __init__(self):
-        self.buffer = None
-        self.capacity = None
-        self.overrun = None
-        self.data_count = None
-
-
-class FieldBusRingBuffer:
-    """FieldBus Ring Buffer Class"""
-
-    def __init__(self, size, data_count):
-        """Initialization of the FieldBus Ring Buffer Class"""
-
-        self.ring_buffer = RingBuffer()
-        self.ring_buffer.capacity = size
-        self.ring_buffer.data_count = data_count
-
-        self.ring_buffer_reset()
-
-    def ring_buffer_reset(self):
-        """Function to initialize some of the FieldBusRingBuf parameters"""
-
-        self.ring_buffer.buffer = deque(maxlen=self.ring_buffer.capacity)
-        self.ring_buffer.overrun = 0
-
-    def ring_buffer_free(self):
-        """Destruction of the FieldBus Ring Buffer"""
-
-        self.ring_buffer = None
-
-    def ring_buffer_empty(self):
-        """Checks if the FieldBus Ring Buffer is empty"""
-
-        return not self.ring_buffer.buffer
-
-    def ring_buffer_size(self):
-        """Retrieves the FieldBus Ring Buffer size"""
-
-        return len(self.ring_buffer.buffer)
-
-    def put_data(self, time_stamp, values):
-        """Insert FieldBusData in the FieldBus Ring Buffer"""
-
-        if not self.ring_buffer:
-            print("FieldBus Ring Buffer is null \n")
-            return
-
-        if self.ring_buffer_size() >= self.ring_buffer.capacity:
-            self.ring_buffer.overrun = 1
-
-        data = FieldBusData()
-        data.time_stamp = time_stamp
-        data.values = values
-
-        self.ring_buffer.buffer.append(data)
-
-    def get_data(self):
-        """Read FieldBusData in the FieldBus Ring Buffer"""
-
-        if not self.ring_buffer:
-            print("FieldBus Ring Buffer is null \n")
-            return 0
-
-        if not self.ring_buffer_empty():
-            data = self.ring_buffer.buffer.popleft()
-
-            return data.time_stamp, data.values, self.ring_buffer.overrun
diff --git a/src/ghsapi/fieldbus_ringbuffer.py b/src/ghsapi/fieldbus_ringbuffer.py
new file mode 100644
index 0000000..0c15483
--- /dev/null
+++ b/src/ghsapi/fieldbus_ringbuffer.py
@@ -0,0 +1,117 @@
+"""FieldBus Ring Buffer"""
+
+from collections import deque
+from .connection import ConnectionHandler
+
+class FieldBusData:
+    """FieldBus incoming packets, includes a timestamp and async values"""
+
+    def __init__(self, dataCount):
+        self.timeStamp = 0
+        self.fValues = [0] * dataCount
+
+class FieldBus:
+    """Struct Definition for the FieldBus Connection"""
+
+    conHandle = ConnectionHandler()
+    ipAddress = None
+    lastPacket = FieldBusData(0)
+
+    def __init__(self, size, dataCount):
+        self.dataHandle = FieldBusRingBuffer(size, dataCount)
+
+
+class FieldBusRingBuffer:
+    """FieldBus Ring Buffer Class"""
+
+    def __init__(self, size, data_count):
+        """Initialization of the FieldBus Ring Buffer Class"""
+
+        self.buffer = [FieldBusData(data_count)] * size
+        self.writeIndex = 0
+        self.readIndex = 0
+        self.capacity = size
+        self.overrun = 0
+        self.data_count = data_count
+
+        self.ring_buffer_reset()
+
+    def ring_buffer_reset(self):
+        """Function to initialize some of the FieldBusRingBuf parameters"""
+
+        self.buffer = [FieldBusData(self.data_count)] * self.capacity
+        self.writeIndex = 0
+        self.readIndex = 0
+        self.overrun = 0
+
+    def ring_buffer_free(self):
+        """Destruction of the FieldBus Ring Buffer"""
+
+        self.buffer = None
+
+    def ring_buffer_is_empty(self):
+        """Checks if the FieldBus Ring Buffer is empty"""
+
+        return (not self.buffer and self.writeIndex == self.readIndex)
+
+    def ring_buffer_get_size(self):
+        """Retrieves the FieldBus Ring Buffer size"""
+
+        if not self.buffer:
+            print("Failed getting size of FieldBus Ring Buffer \n")
+            return 0
+
+        if self.writeIndex >= self.readIndex:
+            size = self.writeIndex - self.readIndex
+        else:
+            size = self.capacity + self.writeIndex - self.readIndex
+
+        return size
+
+    def increment_writing_index(self):
+        """Advances the Writing index"""
+
+        if not self.buffer:
+            print ("Failed accessing to the FieldBus Ring Buffer \n")
+            return
+
+        self.writeIndex = (self.writeIndex + 1) % self.capacity
+
+        if self.writeIndex == self.readIndex:
+            self.overrun = 1
+
+    def increment_reading_index(self):
+        """Advances the Writing index"""
+
+        if not self.buffer:
+            print ("Failed accessing to the FieldBus Ring Buffer \n")
+            return
+
+        self.readIndex = (self.readIndex + 1) % self.capacity
+
+    def put_data(self, time_stamp, values):
+        """Insert FieldBusData in the FieldBus Ring Buffer"""
+
+        if not self.buffer:
+            print("FieldBus Ring Buffer is null \n")
+            return
+
+        self.buffer[self.writeIndex].timeStamp = time_stamp
+        self.buffer[self.writeIndex].fValues = values
+
+        self.increment_writing_index()
+
+    def get_data(self):
+        """Read FieldBusData in the FieldBus Ring Buffer"""
+
+        if not self.buffer:
+            print("FieldBus Ring Buffer is null \n")
+            return 0
+
+        if not self.ring_buffer_is_empty():
+            self.increment_reading_index()
+            return (
+                self.buffer[self.readIndex].timeStamp,
+                self.buffer[self.readIndex].fValues,
+                self.overrun
+            )
diff --git a/src/ghsapi/ghsapi.py b/src/ghsapi/ghsapi.py
index e3bd6f9..e997e37 100644
--- a/src/ghsapi/ghsapi.py
+++ b/src/ghsapi/ghsapi.py
@@ -41,17 +41,8 @@
 from . import manage_recordings_api as _manage_recordings
 from . import recorder_api as _recorder
 from .connection import ConnectionHandler
-from .ghsapi_states import (
-    RETURN_KEY,
-    GHSChannelType,
-    GHSDigitalOutMode,
-    GHSDirection,
-    GHSEnableDisable,
-    GHSReturnValue,
-    GHSSyncStatus,
-    GHSTriggerMode,
-    GHSUserMode,
-)
+from .fieldbus_ringbuffer import FieldBus
+from .ghsapi_states import RETURN_KEY, GHSReturnValue
 
 CLIENT_API_VERSION = 4
 
@@ -65,6 +56,7 @@ class GHS:
 
     def __init__(self):
         self._con_handle = ConnectionHandler()
+        self.fieldbus_handle = FieldBus(0, 0)
 
     # Connection related API functions.
     def ghs_connect(self, ip_address: int, port_num: int) -> str:
@@ -78,9 +70,19 @@ def ghs_connect(self, ip_address: int, port_num: int) -> str:
             * GHSReturnValue - Connect return status.
         """
 
-        return _connection.connect(
+        returnVal = _connection.connect(
             self._con_handle, ip_address, port_num, CLIENT_API_VERSION
         )
+        if returnVal != "OK":
+            self._con_handle = None
+        
+        self.fieldbus_handle.dataHandle = None
+        self.fieldbus_handle.conHandle = ConnectionHandler()
+        self.fieldbus_handle.lastPacket.timeStamp = 0
+        self.fieldbus_handle.lastPacket.fValues = None
+        self.fieldbus_handle.ipAddress = ip_address
+        
+        return returnVal
 
     def ghs_disconnect(self) -> str:
         """Disconnects from a connected mainframe.
@@ -1620,16 +1622,16 @@ def ghs_initiate_fieldbus_data_transfer(
         self,
         update_rate: int,
     ) -> tuple[str, int | None, int | None]:
-        """Opens a new connection for the field bus data, and waits for client
+        """*Opens a new connection for the field bus data, and waits for client
         to connect. Once the client connects, if the acquisition state is
-        active, data is sent to the client. Otherwise nothing is sent.
+        active, data is sent to the client. Otherwise nothing is sent.*
 
-        *If no formulas are present then you get error code
-        back:GHSReturnValue_FieldBusError_NotConfigured if the field bus is
-        already initiated then an error code is
-        returned:GHSReturnValue_FieldBusError_FieldBusEnabled. To change the
-        update rate the field bus needs to be stoped and inititate again with
-        a new update rate.*
+        *If no formulas are present then you get error code back:GHSReturnValue_FieldBusError_NotConfigured*
+
+        *If the field bus is already initiated then an error code is returned:
+        GHSReturnValue_FieldBusError_FieldBusEnabled.*
+
+        *To change the update rate the field bus needs to be stoped and inititated again with a new update rate.*
 
         Args:
             update_rate: (in Hz) The update rate should be a part of the list
@@ -1637,28 +1639,23 @@ def ghs_initiate_fieldbus_data_transfer(
 
         Returns:
             * GHSReturnValue - API return values
-            * update_rate - If the update rate selected by the user is not
-            supported, the mainframe will adjust the update rate, based on a
-            minimum distance from the supported rates and returns back to the
-            client.
-            * data_count - The number of published data on the setup.Timestamp
-            is not included in this count.
+            * update_rate - If the update rate selected by the user is not supported, the mainframe will adjust the update rate based on a minimum distance from the supported rates and returns back to the client.
+            * data_count - The number of published data on the setup. Timestamp is not included in this count.
         """
 
         return _fieldbus.initiate_fieldbus_data_transfer(
             self._con_handle,
             update_rate,
+            self.fieldbus_handle
         )
 
     def ghs_stop_fieldbus_data_transfer(
         self,
     ) -> str:
-        """Closes the socket dedicated for the field bus data and stops
-        transfering data. The ring buffer allocated for the transfer data is
-        deleted.
+        """*Closes the socket dedicated for the field bus data and stops transfering data.
+        The ring buffer allocated for the transfer data is deleted.*
 
-        *Field bus data transfer must have been initiated before calling this
-        function*
+        *Field bus data transfer must have been initiated before calling this function*
 
         Returns:
             * GHSReturnValue - API return values
@@ -1671,13 +1668,11 @@ def ghs_stop_fieldbus_data_transfer(
     def ghs_get_fieldbus_data_count(
         self,
     ) -> tuple[str, int | None]:
-        """Gets the number of data that are configured to be sent through the
-        field bus, excluding the timestamp.
+        """Gets the number of data that are configured to be sent through the field bus, excluding the timestamp.
 
         Returns:
             * GHSReturnValue - API return values
-            * data_count - The number of data that are selected to be
-            published, excluding timestamp.
+            * data_count - The number of data that are selected to be published, excluding timestamp.
         """
 
         return _fieldbus.get_fieldbus_data_count(
@@ -1688,11 +1683,11 @@ def ghs_get_fieldbus_data_name_and_unit(
         self,
         data_index: int,
     ) -> tuple[str, str | None, str | None]:
-        """Gets the name of specific field bus data value, by giving the index
-        of the data value. The number of data values can be retrieved by
-        GHSGetFieldBusDataCount(). In case of no formulas (or reserved values
-        acquisition state and latency) published, an error code is returned:
-        GHSReturnValue_FieldBusError_NoFormulasDeployed.
+        """*Gets the name of specific field bus data value, by giving the index of the data value.
+        The number of data values can be retrieved by GHSGetFieldBusDataCount().*
+
+        *In case of no formulas (or reserved values acquisition state and latency) published,
+        an error code is returned: GHSReturnValue_FieldBusError_NoFormulasDeployed.*
 
         Args:
             data_index: Zero-based index of the data value.
@@ -1710,25 +1705,73 @@ def ghs_get_fieldbus_data_name_and_unit(
 
     def ghs_request_fieldbus_snapshot(
         self,
+        dataCount: int
     ) -> tuple[str, float | None, int | None, tuple[float] | None]:
-        """Request a single snapshot of the field bus data. In this case the
-        timestamp received is not grid aligned. If the system is not acquiring
-        the method returns an error code:GHSReturnValue_SystemNotRecording In
-        case of no formulas you get the error return code
-        back:GHSReturnValue_FieldBusError_NotConfigured if the field bus is
-        already enabled then this method is not allowed.An error return code
-        is returned:FieldBusError_UnavailableFunctionality.
+        """*Request a single snapshot of the field bus data.
+        In this case the timestamp received is not grid aligned.*
+
+        *If the system is not acquiring the method returns an error code:GHSReturnValue_SystemNotRecording*
+
+        *In case of no formulas you get the error return code back:GHSReturnValue_FieldBusError_NotConfigured*
+
+        *If the field bus is already enabled then this method is not allowed.
+        An error return code is returned:FieldBusError_UnavailableFunctionality.*
 
         Returns:
             * GHSReturnValue - API return values
-            * timestamp - of the FieldBus data relative to start of
-            acquisition (not grid aligned) GHSGetAcquisitionStartTime
-            * data_count - Actuall number of elements(formulas) in the data
-            parameter. If number of elements allocated by the customer are
-            less than the actual formulas number, then we return an error code.
+            * timestamp - Timestamp of the FieldBus data relative to start of acquisition (not grid aligned) GHSGetAcquisitionStartTime
+            * data_count - Actual number of elements(formulas) in the data parameter. If number of elements allocated by the customer are less than the actual formulas number, then we return an error code.
             * data - Array of floats that contains the data
         """
 
         return _fieldbus.request_fieldbus_snapshot(
             self._con_handle,
+            dataCount
+        )
+
+    def ghs_receive_fieldbus_data(
+        self,
+    ) -> str:
+        """Used to retrieve the FieldBus data from the new socket connection and write on the buffer.
+
+        *Can be used in a thread and if so, mutual exclusion should be used with GHSStopFieldBusDataTransfer.*
+
+        *This function should be used in a loop if continuous delivery of Async Data is desired.*
+
+        *Field bus data transfer must have been initiated before calling this function.*
+
+        Returns:
+            * GHSReturnValue - API return values
+        """
+
+        return _fieldbus.receive_fieldbus_data(
+            self.fieldbus_handle
+        )
+
+    def ghs_read_next_snapshot(
+        self,
+        call_type: str | int
+    ) -> tuple[str, float | None, float | None, int | None]:
+        """Retrieves the next snapshot in the buffer.
+
+        *The timestamp is grid aligned - as specified by the 'updateRate' argument
+        of the GHSInitiateFieldBusDataTransfer() method.*
+
+        Args:
+            call_type: flag to control the receiving of FieldBus data:
+                        *If set to GHS_BlockingCall it blocks while waiting for new FieldBus data.
+                        *If set to GHS_NonBlockingCall then returns last FieldBus data when no new data available.
+                        *GHS_BlockingCall is the preferred value as this results in the lowest CPU load
+                        and highest data troughput.*
+
+        Returns:
+            * GHSReturnValue - API return values
+            * Timestamp - timestamp of the FieldBus data relative to start of acquisition GHSGetAcquisitionStartTime()
+            * Values - the values published on the FieldBus.
+            * Overrun - is one if overrun happened in the buffer, zero if not.
+        """
+
+        return _fieldbus.read_next_snapshot(
+            self.fieldbus_handle,
+            call_type
         )
diff --git a/src/ghsapi/ghsapi_states.py b/src/ghsapi/ghsapi_states.py
index 87f85b9..2f7634a 100644
--- a/src/ghsapi/ghsapi_states.py
+++ b/src/ghsapi/ghsapi_states.py
@@ -257,6 +257,11 @@
     "Alarm": 4,
 }
 
+GHSFunctionCallType = {
+    "NonBlockingCall": 0,
+    "BlockingCall": 1,
+}
+
 
 def to_string(value: int, ghs_dict: dict) -> str:
     """Get status key by value from dictionary."""